[lldb][NFC] Rename ClangASTContext to TypeSystemClang

[teemperor]

Summary

This commit renames ClangASTContext to TypeSystemClang to better reflect what this class is actually supposed to do
(implement the TypeSystem interface for Clang). It also gets rid of the very confusing situation that we have both a
clang::ASTContext and a ClangASTContext in clang (which sometimes causes Clang people to think I'm fiddling
with Clang's ASTContext when I'm actually just doing LLDB work).

I also have plans to potentially have multiple clang::ASTContext instances associated with one ClangASTContext so
the ASTContext naming will then become even more confusing to people.

[teemperor]

We are currently after a fresh rebranch downstream so now is a good time to rename this without causing merge-conflict hell later on. It would be useful if could get consensus if and to what we should rename this class soon-ish so that I can make this move as painless as possible.

Obviously the contents of this patch are just dummy contents until we agree on a final name. The ClangTypeSystem just seems obvious (and it has the same amount of characters as ClangASTContext so it won't cause any formatting changes when I rename it).

[labath]

TypeSystemClang would probably be more consistent with how other lldb classes are named (SymbolFileDWARF, ValueObjectChild, etc.), but I don't have a big problem with ClangTypeSystem either...

[teemperor]

Both TypeSystemClang and ClangTypeSystem works for me.

[teemperor]

• Rebased to get rid of shady StringRef -> C-String conversion.

[teemperor]

Huh, seems I uploaded to the wrong review

[teemperor]

• Revert to original dummy patch.

[xiaobai]

I like this idea quite a bit, but have no preference for ClangTypeSystem or TypeSystemClang. +1 from me.

[davide]

This is very good, go for it. Should we do the same for Swift? cc: @aprantl
For the future, please CC: me directly on these kind of changes if you want my review, as I might miss them otherwise.

[jingham]

I agree it should be TypeSystemClang, since that's how we name all the plugins. Other that that this seems like a great change. We should do the same for swift to keep things consistent, though that's not relevant to this patch.

[aprantl]

In D72684#1820205, @davide wrote:

This is very good, go for it. Should we do the same for Swift? cc: @aprantl

Yeah, otherwise this is going to be confusing.

[clayborg]

We might also want to move these into lldb/source/Plugins/TypeSystem as well to complete this refactor?

[xiaobai]

In D72684#1820486, @clayborg wrote:

We might also want to move these into lldb/source/Plugins/TypeSystem as well to complete this refactor?

You could move it now, but ValueObject still depends on it (and you would be introducing more plugin dependencies that shouldn't exist). I have a patch here (D69820) removing it that still needs some more work but after that we should be able to move it without introducing any more dependencies.

[teemperor]

In D72684#1820486, @clayborg wrote:

We might also want to move these into lldb/source/Plugins/TypeSystem as well to complete this refactor?

I fully agree but I prefer if we could do this as it's own change. This patch is already huge once I renamed all occurrences of ClangASTContext in the source.

[teemperor]

• Replaced dummy contents with actual patch

[teemperor]

Are there any objections against this? Otherwise I'll land this tomorrow.

[labath]

It looks like everyone is on board with this...

[clayborg]

Looks good. Making TypeSystem's into real plugins in the future would be great too.

lldb/include/lldb/Symbol/ClangASTImporter.h

struct LayoutInfo {
     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
         vbase_offsets;
   };
 
   ClangASTImporter()
       : m_file_manager(clang::FileSystemOptions(),
                        FileSystem::Instance().GetVirtualFileSystem()) {}
 
-  CompilerType CopyType(ClangASTContext &dst, const CompilerType &src_type);
+  CompilerType CopyType(TypeSystemClang &dst, const CompilerType &src_type);
 
   clang::Decl *CopyDecl(clang::ASTContext *dst_ctx, clang::Decl *decl);
 
-  CompilerType DeportType(ClangASTContext &dst, const CompilerType &src_type);
+  CompilerType DeportType(TypeSystemClang &dst, const CompilerType &src_type);
 
   clang::Decl *DeportDecl(clang::ASTContext *dst_ctx, clang::Decl *decl);
 
   /// Sets the layout for the given RecordDecl. The layout will later be
   /// used by Clang's during code generation. Not calling this function for
   /// a RecordDecl will cause that Clang's codegen tries to layout the
   /// record by itself.
   ///

lldb/include/lldb/Symbol/ClangExternalASTSourceCallbacks.h

 //===-- ClangExternalASTSourceCallbacks.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_ClangExternalASTSourceCallbacks_h_
 #define liblldb_ClangExternalASTSourceCallbacks_h_
 
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "clang/AST/ExternalASTSource.h"
 
 namespace lldb_private {
 
-class ClangASTContext;
+class TypeSystemClang;
 
 class ClangExternalASTSourceCallbacks : public clang::ExternalASTSource {
 public:
-  ClangExternalASTSourceCallbacks(ClangASTContext &ast) : m_ast(ast) {}
+  ClangExternalASTSourceCallbacks(TypeSystemClang &ast) : m_ast(ast) {}
 
   void FindExternalLexicalDecls(
       const clang::DeclContext *DC,
       llvm::function_ref<bool(clang::Decl::Kind)> IsKindWeWant,
       llvm::SmallVectorImpl<clang::Decl *> &Result) override;
 
   void CompleteType(clang::TagDecl *tag_decl) override;
 
   void CompleteType(clang::ObjCInterfaceDecl *objc_decl) override;
 
   bool layoutRecordType(
       const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment,
       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
           &BaseOffsets,
       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
           &VirtualBaseOffsets) override;
 
 private:
-  ClangASTContext &m_ast;
+  TypeSystemClang &m_ast;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ClangExternalASTSourceCallbacks_h_

lldb/include/lldb/Symbol/CompilerDeclContext.h

public:
   CompilerDeclContext() = default;
 
   /// Constructs a CompilerDeclContext with the given opaque decl context
   /// and its respective TypeSystem instance.
   ///
   /// This constructor should only be called from the respective TypeSystem
   /// implementation.
   ///
-  /// \see lldb_private::ClangASTContext::CreateDeclContext(clang::DeclContext*)
+  /// \see lldb_private::TypeSystemClang::CreateDeclContext(clang::DeclContext*)
   CompilerDeclContext(TypeSystem *type_system, void *decl_ctx)
       : m_type_system(type_system), m_opaque_decl_ctx(decl_ctx) {}
 
   // Tests
 
   explicit operator bool() const { return IsValid(); }
 
   bool operator<(const CompilerDeclContext &rhs) const {

lldb/include/lldb/Symbol/CompilerType.h

 /// \see lldb_private::TypeSystem
 class CompilerType {
 public:
   /// Creates a CompilerType with the given TypeSystem and opaque compiler type.
   ///
   /// This constructor should only be called from the respective TypeSystem
   /// implementation.
   ///
-  /// \see lldb_private::ClangASTContext::GetType(clang::QualType)
+  /// \see lldb_private::TypeSystemClang::GetType(clang::QualType)
   CompilerType(TypeSystem *type_system, lldb::opaque_compiler_type_t type)
       : m_type(type), m_type_system(type_system) {}
 
   CompilerType(const CompilerType &rhs)
       : m_type(rhs.m_type), m_type_system(rhs.m_type_system) {}
 
   CompilerType() = default;
 

lldb/include/lldb/Symbol/TypeSystem.h

#endif
   virtual bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) = 0;
 
   virtual void DumpSummary(lldb::opaque_compiler_type_t type,
                            ExecutionContext *exe_ctx, Stream *s,
                            const DataExtractor &data,
                            lldb::offset_t data_offset,
                            size_t data_byte_size) = 0;
 
-  // TODO: Determine if these methods should move to ClangASTContext.
+  // TODO: Determine if these methods should move to TypeSystemClang.
 
   virtual bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type,
                                         CompilerType *pointee_type) = 0;
 
   virtual unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) = 0;
 
   virtual bool IsCStringType(lldb::opaque_compiler_type_t type,
                              uint32_t &length) = 0;

lldb/include/lldb/Symbol/TypeSystemClang.h

-//===-- ClangASTContext.h ---------------------------------------*- C++ -*-===//
+//===-- TypeSystemClang.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_ClangASTContext_h_
-#define liblldb_ClangASTContext_h_
+#ifndef liblldb_TypeSystemClang_h_
+#define liblldb_TypeSystemClang_h_
 
 #include <stdint.h>
 
 #include <functional>
 #include <initializer_list>
 #include <map>
 #include <memory>
 #include <set>

 
 class DWARFASTParserClang;
 class PDBASTParser;
 
 namespace lldb_private {
 
 class Declaration;
 
-class ClangASTContext : public TypeSystem {
+class TypeSystemClang : public TypeSystem {
   // LLVM RTTI support
   static char ID;
 
 public:
   typedef void (*CompleteTagDeclCallback)(void *baton, clang::TagDecl *);
   typedef void (*CompleteObjCInterfaceDeclCallback)(void *baton,
                                                     clang::ObjCInterfaceDecl *);
 
   // llvm casting support
   bool isA(const void *ClassID) const override { return ClassID == &ID; }
   static bool classof(const TypeSystem *ts) { return ts->isA(&ID); }
 
-  /// Constructs a ClangASTContext with an ASTContext using the given triple.
+  /// Constructs a TypeSystemClang with an ASTContext using the given triple.
   ///
-  /// \param name The name for the ClangASTContext (for logging purposes)
+  /// \param name The name for the TypeSystemClang (for logging purposes)
   /// \param triple The llvm::Triple used for the ASTContext. The triple defines
   ///               certain characteristics of the ASTContext and its types
   ///               (e.g., whether certain primitive types exist or what their
   ///               signedness is).
-  explicit ClangASTContext(llvm::StringRef name, llvm::Triple triple);
+  explicit TypeSystemClang(llvm::StringRef name, llvm::Triple triple);
 
-  /// Constructs a ClangASTContext that uses an existing ASTContext internally.
+  /// Constructs a TypeSystemClang that uses an existing ASTContext internally.
   /// Useful when having an existing ASTContext created by Clang.
   ///
-  /// \param name The name for the ClangASTContext (for logging purposes)
+  /// \param name The name for the TypeSystemClang (for logging purposes)
   /// \param existing_ctxt An existing ASTContext.
-  explicit ClangASTContext(llvm::StringRef name,
+  explicit TypeSystemClang(llvm::StringRef name,
                            clang::ASTContext &existing_ctxt);
 
-  ~ClangASTContext() override;
+  ~TypeSystemClang() override;
 
   void Finalize() override;
 
   // PluginInterface functions
   ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
   static ConstString GetPluginNameStatic();
 
   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
                                            Module *module, Target *target);
 
   static LanguageSet GetSupportedLanguagesForTypes();
   static LanguageSet GetSupportedLanguagesForExpressions();
 
   static void Initialize();
 
   static void Terminate();
 
-  static ClangASTContext *GetASTContext(clang::ASTContext *ast_ctx);
+  static TypeSystemClang *GetASTContext(clang::ASTContext *ast_ctx);
 
-  static ClangASTContext *GetScratch(Target &target,
+  static TypeSystemClang *GetScratch(Target &target,
                                      bool create_on_demand = true) {
     auto type_system_or_err = target.GetScratchTypeSystemForLanguage(
         lldb::eLanguageTypeC, create_on_demand);
     if (auto err = type_system_or_err.takeError()) {
       LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET),
-                     std::move(err), "Couldn't get scratch ClangASTContext");
+                     std::move(err), "Couldn't get scratch TypeSystemClang");
       return nullptr;
     }
-    return llvm::dyn_cast<ClangASTContext>(&type_system_or_err.get());
+    return llvm::dyn_cast<TypeSystemClang>(&type_system_or_err.get());
   }
 
-  /// Returns the display name of this ClangASTContext that indicates what
+  /// Returns the display name of this TypeSystemClang that indicates what
   /// purpose it serves in LLDB. Used for example in logs.
   llvm::StringRef getDisplayName() const { return m_display_name; }
 
   clang::ASTContext &getASTContext();
 
   clang::MangleContext *getMangleContext();
 
   std::shared_ptr<clang::TargetOptions> &getTargetOptions();
 
   clang::TargetInfo *getTargetInfo();
 
   void setSema(clang::Sema *s);
   clang::Sema *getSema() { return m_sema; }
 
   const char *GetTargetTriple();
 
   void SetExternalSource(
       llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> &ast_source_up);
 
   bool GetCompleteDecl(clang::Decl *decl) {
-    return ClangASTContext::GetCompleteDecl(&getASTContext(), decl);
+    return TypeSystemClang::GetCompleteDecl(&getASTContext(), decl);
   }
 
   static void DumpDeclHiearchy(clang::Decl *decl);
 
   static void DumpDeclContextHiearchy(clang::DeclContext *decl_ctx);
 
   static bool DeclsAreEquivalent(clang::Decl *lhs_decl, clang::Decl *rhs_decl);
 
public:
   clang::TranslationUnitDecl *GetTranslationUnitDecl() {
     return getASTContext().getTranslationUnitDecl();
   }
 
   static bool AreTypesSame(CompilerType type1, CompilerType type2,
                            bool ignore_qualifiers = false);
 
   /// Creates a CompilerType form the given QualType with the current
-  /// ClangASTContext instance as the CompilerType's typesystem.
+  /// TypeSystemClang instance as the CompilerType's typesystem.
   /// \param qt The QualType for a type that belongs to the ASTContext of this
-  ///           ClangASTContext.
+  ///           TypeSystemClang.
   /// \return The CompilerType representing the given QualType. If the
   ///         QualType's type pointer is a nullptr then the function returns an
   ///         invalid CompilerType.
   CompilerType GetType(clang::QualType qt) {
     if (qt.getTypePtrOrNull() == nullptr)
       return CompilerType();
-    // Check that the type actually belongs to this ClangASTContext.
+    // Check that the type actually belongs to this TypeSystemClang.
     assert(qt->getAsTagDecl() == nullptr ||
            &qt->getAsTagDecl()->getASTContext() == &getASTContext());
     return CompilerType(this, qt.getAsOpaquePtr());
   }
 
   CompilerType GetTypeForDecl(clang::NamedDecl *decl);
 
   CompilerType GetTypeForDecl(clang::TagDecl *decl);
public:
 
   bool SetTagTypeKind(clang::QualType type, int kind) const;
 
   bool SetDefaultAccessForRecordFields(clang::RecordDecl *record_decl,
                                        int default_accessibility,
                                        int *assigned_accessibilities,
                                        size_t num_assigned_accessibilities);
 
-  // Returns a mask containing bits from the ClangASTContext::eTypeXXX
+  // Returns a mask containing bits from the TypeSystemClang::eTypeXXX
   // enumerations
 
   // Namespace Declarations
 
   clang::NamespaceDecl *
   GetUniqueNamespaceDeclaration(const char *name, clang::DeclContext *decl_ctx,
                                 bool is_inline = false);
 
public:
 
   static CompilerType GetFloatTypeFromBitSize(clang::ASTContext *ast,
                                               size_t bit_size);
 
   // TypeSystem methods
   DWARFASTParser *GetDWARFParser() override;
   PDBASTParser *GetPDBParser() override;
 
-  // ClangASTContext callbacks for external source lookups.
+  // TypeSystemClang callbacks for external source lookups.
   void CompleteTagDecl(clang::TagDecl *);
 
   void CompleteObjCInterfaceDecl(clang::ObjCInterfaceDecl *);
 
   bool LayoutRecordType(
       const clang::RecordDecl *record_decl, uint64_t &size, uint64_t &alignment,
       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
public:
   CompilerType DeclGetFunctionArgumentType(void *opaque_decl,
                                            size_t arg_idx) override;
 
   CompilerType GetTypeForDecl(void *opaque_decl) override;
 
   // CompilerDeclContext override functions
 
   /// Creates a CompilerDeclContext from the given DeclContext
-  /// with the current ClangASTContext instance as its typesystem.
+  /// with the current TypeSystemClang instance as its typesystem.
   /// The DeclContext has to come from the ASTContext of this
-  /// ClangASTContext.
+  /// TypeSystemClang.
   CompilerDeclContext CreateDeclContext(clang::DeclContext *ctx);
 
   std::vector<CompilerDecl>
   DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
                             const bool ignore_using_decls) override;
 
   ConstString DeclContextGetName(void *opaque_decl_ctx) override;
 
public:
 
   static clang::NamespaceDecl *
   DeclContextGetAsNamespaceDecl(const CompilerDeclContext &dc);
 
   static ClangASTMetadata *DeclContextGetMetaData(const CompilerDeclContext &dc,
                                                   const clang::Decl *object);
 
   static clang::ASTContext *
-  DeclContextGetClangASTContext(const CompilerDeclContext &dc);
+  DeclContextGetTypeSystemClang(const CompilerDeclContext &dc);
 
   // Tests
 
   bool IsArrayType(lldb::opaque_compiler_type_t type,
                    CompilerType *element_type, uint64_t *size,
                    bool *is_incomplete) override;
 
   bool IsVectorType(lldb::opaque_compiler_type_t type,
#endif
   GetAsCXXRecordDecl(lldb::opaque_compiler_type_t type);
 
   static clang::ObjCInterfaceDecl *
   GetAsObjCInterfaceDecl(const CompilerType &type);
 
   clang::ClassTemplateDecl *ParseClassTemplateDecl(
       clang::DeclContext *decl_ctx, lldb::AccessType access_type,
       const char *parent_name, int tag_decl_kind,
-      const ClangASTContext::TemplateParameterInfos &template_param_infos);
+      const TypeSystemClang::TemplateParameterInfos &template_param_infos);
 
   clang::BlockDecl *CreateBlockDeclaration(clang::DeclContext *ctx);
 
   clang::UsingDirectiveDecl *
   CreateUsingDirectiveDeclaration(clang::DeclContext *decl_ctx,
                                   clang::NamespaceDecl *ns_decl);
 
   clang::UsingDecl *CreateUsingDeclaration(clang::DeclContext *current_decl_ctx,
#endif
 
   clang::DeclarationName
   GetDeclarationName(const char *name, const CompilerType &function_clang_type);
 
 private:
   const clang::ClassTemplateSpecializationDecl *
   GetAsTemplateSpecialization(lldb::opaque_compiler_type_t type);
 
-  // Classes that inherit from ClangASTContext can see and modify these
+  // Classes that inherit from TypeSystemClang can see and modify these
   std::string m_target_triple;
   std::unique_ptr<clang::ASTContext> m_ast_up;
   std::unique_ptr<clang::LangOptions> m_language_options_up;
   std::unique_ptr<clang::FileManager> m_file_manager_up;
   std::unique_ptr<clang::SourceManager> m_source_manager_up;
   std::unique_ptr<clang::DiagnosticsEngine> m_diagnostics_engine_up;
   std::unique_ptr<clang::DiagnosticConsumer> m_diagnostic_consumer_up;
   std::shared_ptr<clang::TargetOptions> m_target_options_rp;
   std::unique_ptr<clang::TargetInfo> m_target_info_up;
   std::unique_ptr<clang::IdentifierTable> m_identifier_table_up;
   std::unique_ptr<clang::SelectorTable> m_selector_table_up;
   std::unique_ptr<clang::Builtin::Context> m_builtins_up;
   std::unique_ptr<DWARFASTParserClang> m_dwarf_ast_parser_up;
   std::unique_ptr<PDBASTParser> m_pdb_ast_parser_up;
   std::unique_ptr<clang::MangleContext> m_mangle_ctx_up;
   uint32_t m_pointer_byte_size = 0;
   bool m_ast_owned = false;
-  /// A string describing what this ClangASTContext represents (e.g.,
+  /// A string describing what this TypeSystemClang represents (e.g.,
   /// AST for debug information, an expression, some other utility ClangAST).
   /// Useful for logging and debugging.
   std::string m_display_name;
 
   typedef llvm::DenseMap<const clang::Decl *, ClangASTMetadata> DeclMetadataMap;
   /// Maps Decls to their associated ClangASTMetadata.
   DeclMetadataMap m_decl_metadata;
 
   typedef llvm::DenseMap<const clang::Type *, ClangASTMetadata> TypeMetadataMap;
   /// Maps Types to their associated ClangASTMetadata.
   TypeMetadataMap m_type_metadata;
 
   /// The sema associated that is currently used to build this ASTContext.
   /// May be null if we are already done parsing this ASTContext or the
   /// ASTContext wasn't created by parsing source code.
   clang::Sema *m_sema = nullptr;
 
-  // For ClangASTContext only
-  ClangASTContext(const ClangASTContext &);
-  const ClangASTContext &operator=(const ClangASTContext &);
+  // For TypeSystemClang only
+  TypeSystemClang(const TypeSystemClang &);
+  const TypeSystemClang &operator=(const TypeSystemClang &);
   /// Creates the internal ASTContext.
   void CreateASTContext();
   void SetTargetTriple(llvm::StringRef target_triple);
 };
 
-class ClangASTContextForExpressions : public ClangASTContext {
+class TypeSystemClangForExpressions : public TypeSystemClang {
 public:
-  ClangASTContextForExpressions(Target &target, llvm::Triple triple);
+  TypeSystemClangForExpressions(Target &target, llvm::Triple triple);
 
-  ~ClangASTContextForExpressions() override = default;
+  ~TypeSystemClangForExpressions() override = default;
 
   void Finalize() override;
 
   UserExpression *
   GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
                     lldb::LanguageType language,
                     Expression::ResultType desired_type,
                     const EvaluateExpressionOptions &options,
private:
   std::unique_ptr<PersistentExpressionState>
       m_persistent_variables; // These are the persistent variables associated
                               // with this process for the expression parser
   std::unique_ptr<ClangASTSource> m_scratch_ast_source_up;
 };
 
 } // namespace lldb_private
 
-#endif // liblldb_ClangASTContext_h_
+#endif // liblldb_TypeSystemClang_h_

lldb/include/lldb/lldb-forward.h

 class BreakpointPrecondition;
 class BreakpointResolver;
 class BreakpointSite;
 class BreakpointSiteList;
 class BroadcastEventSpec;
 class Broadcaster;
 class BroadcasterManager;
 class CallFrameInfo;
-class ClangASTContext;
+class TypeSystemClang;
 class ClangASTImporter;
 class ClangASTMetadata;
 class ClangASTSource;
 class ClangExpressionDeclMap;
 class ClangExpressionParser;
 class ClangExpressionVariable;
 class ClangModulesDeclVendor;
 class ClangPersistentVariables;

 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::ClangASTContext> ClangASTContextUP;
+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;

lldb/packages/Python/lldbsuite/test/lang/c/enum_types/TestEnumTypes.py

def test(self):
                     patterns=[' = C$'])
         self.expect("fr var ab", DATA_TYPES_DISPLAYED_CORRECTLY,
                     patterns=[' = AB$'])
         self.expect("fr var ac", DATA_TYPES_DISPLAYED_CORRECTLY,
                     patterns=[' = A | C$'])
         self.expect("fr var all", DATA_TYPES_DISPLAYED_CORRECTLY,
                     patterns=[' = ALL$'])
         # Test that an enum that doesn't match the heuristic we use in
-        # ClangASTContext::DumpEnumValue, gets printed as a raw integer.
+        # TypeSystemClang::DumpEnumValue, gets printed as a raw integer.
         self.expect("fr var omega", DATA_TYPES_DISPLAYED_CORRECTLY,
                     patterns=[' = 7$'])
         # Test the behavior in case have a variable of a type considered
         # 'bitfield' by the heuristic, but the value isn't actually fully
         # covered by the enumerators.
         self.expect("p (enum bitfield)nonsense", DATA_TYPES_DISPLAYED_CORRECTLY,
                     patterns=[' = B | C | 0x10$'])
 

lldb/source/API/SystemInitializerFull.cpp

 #if LLDB_ENABLE_LUA
 #include "Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.h"
 #endif
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Initialization/SystemInitializerCommon.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Utility/Timer.h"
 
 #include "Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h"
 #include "Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h"
 #include "Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h"
 #include "Plugins/ABI/SysV-arc/ABISysV_arc.h"
 #include "Plugins/ABI/SysV-arm/ABISysV_arm.h"
 #include "Plugins/ABI/SysV-arm64/ABISysV_arm64.h"
#endif
   PlatformMacOSX::Initialize();
 
   // Initialize LLVM and Clang
   llvm::InitializeAllTargets();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
-  ClangASTContext::Initialize();
+  TypeSystemClang::Initialize();
 
 #define LLVM_TARGET(t) LLDB_PROCESS_ ## t(Initialize)
 #include "llvm/Config/Targets.def"
 
   ArchitectureArm::Initialize();
   ArchitectureMips::Initialize();
   ArchitecturePPC64::Initialize();
 
void SystemInitializerFull::Terminate() {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   Debugger::SettingsTerminate();
 
   // Terminate and unload and loaded system or user LLDB plug-ins
   PluginManager::Terminate();
 
-  ClangASTContext::Terminate();
+  TypeSystemClang::Terminate();
 
   ArchitectureArm::Terminate();
   ArchitectureMips::Terminate();
   ArchitecturePPC64::Terminate();
 
 #define LLVM_TARGET(t) LLDB_PROCESS_ ## t(Terminate)
 #include "llvm/Config/Targets.def"
 

lldb/source/Core/ValueObject.cpp

 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/TypeFormat.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Host/Config.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Declaration.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Language.h"

 }
 
 bool ValueObject::GetBaseClassPath(Stream &s) {
   if (IsBaseClass()) {
     bool parent_had_base_class =
         GetParent() && GetParent()->GetBaseClassPath(s);
     CompilerType compiler_type = GetCompilerType();
     llvm::Optional<std::string> cxx_class_name =
-        ClangASTContext::GetCXXClassName(compiler_type);
+        TypeSystemClang::GetCXXClassName(compiler_type);
     if (cxx_class_name) {
       if (parent_had_base_class)
         s.PutCString("::");
       s.PutCString(cxx_class_name.getValue());
     }
     return parent_had_base_class || cxx_class_name;
   }
   return false;

lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

 #include "Utility/PPC64LE_DWARF_Registers.h"
 #include "Utility/PPC64_DWARF_Registers.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectRegister.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
if (m_type.IsHomogeneousAggregate(&elem_type)) {
         m_dst_offs += *elem_size;
       }
       return BuildValueObject();
     }
 
     // case 3: get from GPRs
 
     // first, check if this is a packed struct or not
-    ClangASTContext *ast =
-        llvm::dyn_cast<ClangASTContext>(m_type.GetTypeSystem());
+    TypeSystemClang *ast =
+        llvm::dyn_cast<TypeSystemClang>(m_type.GetTypeSystem());
     if (ast) {
-      clang::RecordDecl *record_decl = ClangASTContext::GetAsRecordDecl(m_type);
+      clang::RecordDecl *record_decl = TypeSystemClang::GetAsRecordDecl(m_type);
 
       if (record_decl) {
         auto attrs = record_decl->attrs();
         for (const auto &attr : attrs) {
           if (attr->getKind() == clang::attr::Packed) {
             m_packed = true;
             break;
           }

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Host/FileSystem.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
if (target.ReadMemory(tls_addr, false, buf, tsl_data_size, error) ==
         if (tid_pos != m_tid_to_tls_map.end()) {
           auto tls_pos = tid_pos->second.find(pthread_key);
           if (tls_pos != tid_pos->second.end()) {
             return tls_pos->second + tls_offset;
           }
         }
         StackFrameSP frame_sp = thread_sp->GetStackFrameAtIndex(0);
         if (frame_sp) {
-          ClangASTContext *clang_ast_context =
-              ClangASTContext::GetScratch(target);
+          TypeSystemClang *clang_ast_context =
+              TypeSystemClang::GetScratch(target);
 
           if (!clang_ast_context)
             return LLDB_INVALID_ADDRESS;
 
           CompilerType clang_void_ptr_type =
               clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
           Address pthread_getspecific_addr = GetPthreadSetSpecificAddress();
           if (pthread_getspecific_addr.IsValid()) {

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp

 //===-- DynamicLoaderMacOS.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 "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
if (dyld_instance->m_image_infos_stop_id != UINT32_MAX &&
     return false;
   }
 
   const lldb::ABISP &abi = process->GetABI();
   if (abi) {
     // Build up the value array to store the three arguments given above, then
     // get the values from the ABI:
 
-    ClangASTContext *clang_ast_context =
-        ClangASTContext::GetScratch(process->GetTarget());
+    TypeSystemClang *clang_ast_context =
+        TypeSystemClang::GetScratch(process->GetTarget());
     if (!clang_ast_context)
       return false;
 
     ValueList argument_values;
 
     Value mode_value;    // enum dyld_notify_mode { dyld_notify_adding=0,
                          // dyld_notify_removing=1, dyld_notify_remove_all=2 };
     Value count_value;   // unsigned long count

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

 //===-- DynamicLoaderMacOSXDYLD.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 "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
bool DynamicLoaderMacOSXDYLD::NotifyBreakpointHit(
   if (dyld_instance->InitializeFromAllImageInfos())
     return dyld_instance->GetStopWhenImagesChange();
 
   const lldb::ABISP &abi = process->GetABI();
   if (abi) {
     // Build up the value array to store the three arguments given above, then
     // get the values from the ABI:
 
-    ClangASTContext *clang_ast_context =
-        ClangASTContext::GetScratch(process->GetTarget());
+    TypeSystemClang *clang_ast_context =
+        TypeSystemClang::GetScratch(process->GetTarget());
     if (!clang_ast_context)
       return false;
 
     ValueList argument_values;
     Value input_value;
 
     CompilerType clang_void_ptr_type =
         clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();

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

 //===-- ASTResultSynthesizer.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 "ASTResultSynthesizer.h"
 
 #include "ClangPersistentVariables.h"
 
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "stdlib.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"

 
 void ASTResultSynthesizer::CommitPersistentDecls() {
   auto *state =
       m_target.GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC);
   if (!state)
     return;
 
   auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state);
-  ClangASTContext *scratch_ctx = ClangASTContext::GetScratch(m_target);
+  TypeSystemClang *scratch_ctx = TypeSystemClang::GetScratch(m_target);
 
   for (clang::NamedDecl *decl : m_decls) {
     StringRef name = decl->getName();
     ConstString name_cs(name.str().c_str());
 
     Decl *D_scratch = m_target.GetClangASTImporter()->DeportDecl(
         &scratch_ctx->getASTContext(), decl);
 

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

public:
   }
   uint32_t GetNumExternalSelectors() override { return 0; }
   clang::CXXBaseSpecifier *
   GetExternalCXXBaseSpecifiers(uint64_t Offset) override {
     return nullptr;
   }
   void MaterializeVisibleDecls(const clang::DeclContext *DC) { return; }
 
-  void InstallASTContext(ClangASTContext &ast_context);
+  void InstallASTContext(TypeSystemClang &ast_context);
 
   //
   // APIs for ExternalASTSource
   //
 
   /// Look up all Decls that match a particular name.  Only handles
   /// Identifiers and DeclContexts that are either NamespaceDecls or
   /// TranslationUnitDecls.  Calls SetExternalVisibleDeclsForName with the
protected:
   /// Find all Objective-C properties and ivars with a given name.
   ///
   /// \param[in] context
   ///     The NameSearchContext that can construct Decls for this name.
   ///     Its m_decl_name contains the name and its m_decl_context
   ///     is the containing object.
   void FindObjCPropertyAndIvarDecls(NameSearchContext &context);
 
-  /// A wrapper for ClangASTContext::CopyType that sets a flag that
+  /// A wrapper for TypeSystemClang::CopyType that sets a flag that
   /// indicates that we should not respond to queries during import.
   ///
   /// \param[in] src_type
   ///     The source type.
   ///
   /// \return
   ///     The imported type.
   CompilerType GuardedCopyType(const CompilerType &src_type);
protected:
 
   bool m_import_in_progress;
   bool m_lookups_enabled;
 
   /// The target to use in finding variables and types.
   const lldb::TargetSP m_target;
   /// The AST context requests are coming in for.
   clang::ASTContext *m_ast_context;
-  /// The ClangASTContext for m_ast_context.
-  ClangASTContext *m_clang_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::set<const clang::Decl *> m_active_lexical_decls;
   std::set<const char *> m_active_lookups;
 };
 

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

 //===-- ClangASTSource.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 "ClangASTSource.h"
 
 #include "ClangDeclVendor.h"
 #include "ClangModulesDeclVendor.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TaggedASTType.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "clang/AST/ASTContext.h"

 
 ClangASTSource::ClangASTSource(const lldb::TargetSP &target,
                                const lldb::ClangASTImporterSP &importer)
     : m_import_in_progress(false), m_lookups_enabled(false), m_target(target),
       m_ast_context(nullptr), m_active_lexical_decls(), m_active_lookups() {
   m_ast_importer_sp = importer;
 }
 
-void ClangASTSource::InstallASTContext(ClangASTContext &clang_ast_context) {
+void ClangASTSource::InstallASTContext(TypeSystemClang &clang_ast_context) {
   m_ast_context = &clang_ast_context.getASTContext();
   m_clang_ast_context = &clang_ast_context;
   m_file_manager = &m_ast_context->getSourceManager().getFileManager();
   m_ast_importer_sp->InstallMapCompleter(m_ast_context, *this);
 }
 
 ClangASTSource::~ClangASTSource() {
   if (!m_ast_importer_sp)
     return;
 
   m_ast_importer_sp->ForgetDestination(m_ast_context);
 
   if (!m_target)
     return;
   // We are in the process of destruction, don't create clang ast context on
   // demand by passing false to
-  // Target::GetScratchClangASTContext(create_on_demand).
-  ClangASTContext *scratch_clang_ast_context =
-      ClangASTContext::GetScratch(*m_target, false);
+  // Target::GetScratchTypeSystemClang(create_on_demand).
+  TypeSystemClang *scratch_clang_ast_context =
+      TypeSystemClang::GetScratch(*m_target, false);
 
   if (!scratch_clang_ast_context)
     return;
 
   clang::ASTContext &scratch_ast_context =
       scratch_clang_ast_context->getASTContext();
 
   if (m_ast_context != &scratch_ast_context && m_ast_importer_sp)
if (const NamespaceDecl *namespace_context =
           continue;
 
         TagDecl *candidate_tag_decl =
             const_cast<TagDecl *>(tag_type->getDecl());
 
         // We have found a type by basename and we need to make sure the decl
         // contexts are the same before we can try to complete this type with
         // another
-        if (!ClangASTContext::DeclsAreEquivalent(tag_decl, candidate_tag_decl))
+        if (!TypeSystemClang::DeclsAreEquivalent(tag_decl, candidate_tag_decl))
           continue;
 
         if (m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl,
                                                          candidate_tag_decl))
           found = true;
       }
     }
   }
if (decl_name.isObjCZeroArgSelector()) {
     original_selector =
         original_ctx->Selectors.getSelector(num_args, idents.data());
   }
 
   DeclarationName original_decl_name(original_selector);
 
   llvm::SmallVector<NamedDecl *, 1> methods;
 
-  ClangASTContext::GetCompleteDecl(original_ctx, original_interface_decl);
+  TypeSystemClang::GetCompleteDecl(original_ctx, original_interface_decl);
 
   if (ObjCMethodDecl *instance_method_decl =
           original_interface_decl->lookupInstanceMethod(original_selector)) {
     methods.push_back(instance_method_decl);
   } else if (ObjCMethodDecl *class_method_decl =
                  original_interface_decl->lookupClassMethod(
                      original_selector)) {
     methods.push_back(class_method_decl);
for (uint32_t i = 0, e = sc_list.GetSize(); i != e; ++i) {
       if (!sc.function)
         continue;
 
       CompilerDeclContext function_decl_ctx = sc.function->GetDeclContext();
       if (!function_decl_ctx)
         continue;
 
       ObjCMethodDecl *method_decl =
-          ClangASTContext::DeclContextGetAsObjCMethodDecl(function_decl_ctx);
+          TypeSystemClang::DeclContextGetAsObjCMethodDecl(function_decl_ctx);
 
       if (!method_decl)
         continue;
 
       ObjCInterfaceDecl *found_interface_decl =
           method_decl->getClassInterface();
 
       if (!found_interface_decl)
bool ClangASTSource::layoutRecordType(const RecordDecl *record, uint64_t &size,
 
   if (origin_record.IsInvalid())
     return false;
 
   FieldOffsetMap origin_field_offsets;
   BaseOffsetMap origin_base_offsets;
   BaseOffsetMap origin_virtual_base_offsets;
 
-  ClangASTContext::GetCompleteDecl(
+  TypeSystemClang::GetCompleteDecl(
       &origin_record->getASTContext(),
       const_cast<RecordDecl *>(origin_record.decl));
 
   clang::RecordDecl *definition = origin_record.decl->getDefinition();
   if (!definition || !definition->isCompleteDefinition())
     return false;
 
   const ASTRecordLayout &record_layout(
NamespaceDecl *ClangASTSource::AddNamespace(
     NameSearchContext &context,
     ClangASTImporter::NamespaceMapSP &namespace_decls) {
   if (!namespace_decls)
     return nullptr;
 
   const CompilerDeclContext &namespace_decl = namespace_decls->begin()->second;
 
   clang::ASTContext *src_ast =
-      ClangASTContext::DeclContextGetClangASTContext(namespace_decl);
+      TypeSystemClang::DeclContextGetTypeSystemClang(namespace_decl);
   if (!src_ast)
     return nullptr;
   clang::NamespaceDecl *src_namespace_decl =
-      ClangASTContext::DeclContextGetAsNamespaceDecl(namespace_decl);
+      TypeSystemClang::DeclContextGetAsNamespaceDecl(namespace_decl);
 
   if (!src_namespace_decl)
     return nullptr;
 
   Decl *copied_decl = CopyDecl(src_namespace_decl);
 
   if (!copied_decl)
     return nullptr;
if (m_ast_importer_sp) {
     return m_ast_importer_sp->GetDeclOrigin(decl);
   } else {
     // this can happen early enough that no ExternalASTSource is installed.
     return ClangASTImporter::DeclOrigin();
   }
 }
 
 CompilerType ClangASTSource::GuardedCopyType(const CompilerType &src_type) {
-  ClangASTContext *src_ast =
-      llvm::dyn_cast_or_null<ClangASTContext>(src_type.GetTypeSystem());
+  TypeSystemClang *src_ast =
+      llvm::dyn_cast_or_null<TypeSystemClang>(src_type.GetTypeSystem());
   if (src_ast == nullptr)
     return CompilerType();
 
   SetImportInProgress(true);
 
   QualType copied_qual_type;
 
   if (m_ast_importer_sp) {

 }
 
 clang::NamedDecl *NameSearchContext::AddVarDecl(const CompilerType &type) {
   assert(type && "Type for variable must be valid!");
 
   if (!type.IsValid())
     return nullptr;
 
-  ClangASTContext *lldb_ast =
-      llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
+  TypeSystemClang *lldb_ast =
+      llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
   if (!lldb_ast)
     return nullptr;
 
   IdentifierInfo *ii = m_decl_name.getAsIdentifierInfo();
 
   clang::ASTContext &ast = lldb_ast->getASTContext();
 
   clang::NamedDecl *Decl = VarDecl::Create(
clang::NamedDecl *NameSearchContext::AddFunDecl(const CompilerType &type,
   assert(type && "Type for variable must be valid!");
 
   if (!type.IsValid())
     return nullptr;
 
   if (m_function_types.count(type))
     return nullptr;
 
-  ClangASTContext *lldb_ast =
-      llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
+  TypeSystemClang *lldb_ast =
+      llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
   if (!lldb_ast)
     return nullptr;
 
   m_function_types.insert(type);
 
   QualType qual_type(ClangUtil::GetQualType(type));
 
   clang::ASTContext &ast = lldb_ast->getASTContext();
clang::NamedDecl *NameSearchContext::AddFunDecl(const CompilerType &type,
 
   // If this is an operator (e.g. operator new or operator==), only insert the
   // declaration we inferred from the symbol if we can provide the correct
   // number of arguments. We shouldn't really inject random decl(s) for
   // functions that are analyzed semantically in a special way, otherwise we
   // will crash in clang.
   clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
   if (func_proto_type &&
-      ClangASTContext::IsOperator(decl_name.getAsString().c_str(), op_kind)) {
-    if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount(
+      TypeSystemClang::IsOperator(decl_name.getAsString().c_str(), op_kind)) {
+    if (!TypeSystemClang::CheckOverloadedOperatorKindParameterCount(
             false, op_kind, func_proto_type->getNumParams()))
       return nullptr;
   }
   m_decls.push_back(func_decl);
 
   return func_decl;
 }
 

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

 //===-- ClangDeclVendor.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 "Plugins/ExpressionParser/Clang/ClangDeclVendor.h"
 
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Utility/ConstString.h"
 
 using namespace lldb_private;
 
 uint32_t ClangDeclVendor::FindDecls(ConstString name, bool append,
                                     uint32_t max_matches,
                                     std::vector<clang::NamedDecl *> &decls) {
   if (!append)

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

private:
   ///     The type for *this.
   void AddThisType(NameSearchContext &context, const TypeFromUser &type,
                    unsigned int current_id);
 
   /// Move a type out of the current ASTContext into another, but make sure to
   /// export all components of the type also.
   ///
   /// \param[in] target
-  ///     The ClangASTContext to move to.
+  ///     The TypeSystemClang to move to.
   /// \param[in] source
-  ///     The ClangASTContext to move from.  This is assumed to be going away.
+  ///     The TypeSystemClang to move from.  This is assumed to be going away.
   /// \param[in] parser_type
   ///     The type as it appears in the source context.
   ///
   /// \return
   ///     Returns the moved type, or an empty type if there was a problem.
-  TypeFromUser DeportType(ClangASTContext &target, ClangASTContext &source,
+  TypeFromUser DeportType(TypeSystemClang &target, TypeSystemClang &source,
                           TypeFromParser parser_type);
 
-  ClangASTContext *GetClangASTContext();
+  TypeSystemClang *GetTypeSystemClang();
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ClangExpressionDeclMap_h_

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

 #include "ClangPersistentVariables.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Expression/Materializer.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
else if (exe_ctx.GetProcessPtr()) {
     m_parser_vars->m_sym_ctx.Clear(true);
     m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
   }
 
   if (target) {
     m_parser_vars->m_persistent_vars = llvm::cast<ClangPersistentVariables>(
         target->GetPersistentExpressionStateForLanguage(eLanguageTypeC));
 
-    if (!ClangASTContext::GetScratch(*target))
+    if (!TypeSystemClang::GetScratch(*target))
       return false;
   }
 
   m_parser_vars->m_target_info = GetTargetInfo();
   m_parser_vars->m_materializer = materializer;
 
   return true;
 }
if (target) {
       ret.byte_order = target->GetArchitecture().GetByteOrder();
       ret.address_byte_size = target->GetArchitecture().GetAddressByteSize();
     }
   }
 
   return ret;
 }
 
-TypeFromUser ClangExpressionDeclMap::DeportType(ClangASTContext &target,
-                                                ClangASTContext &source,
+TypeFromUser ClangExpressionDeclMap::DeportType(TypeSystemClang &target,
+                                                TypeSystemClang &source,
                                                 TypeFromParser parser_type) {
-  assert(&target == ClangASTContext::GetScratch(*m_target));
+  assert(&target == TypeSystemClang::GetScratch(*m_target));
   assert((TypeSystem *)&source == parser_type.GetTypeSystem());
   assert(&source.getASTContext() == m_ast_context);
 
   if (m_ast_importer_sp) {
     return TypeFromUser(m_ast_importer_sp->DeportType(target, parser_type));
   } else {
     lldbassert(0 && "No mechanism for deporting a type!");
     return TypeFromUser();
   }
 }
 
 bool ClangExpressionDeclMap::AddPersistentVariable(const NamedDecl *decl,
                                                    ConstString name,
                                                    TypeFromParser parser_type,
                                                    bool is_result,
                                                    bool is_lvalue) {
   assert(m_parser_vars.get());
 
-  ClangASTContext *ast =
-      llvm::dyn_cast_or_null<ClangASTContext>(parser_type.GetTypeSystem());
+  TypeSystemClang *ast =
+      llvm::dyn_cast_or_null<TypeSystemClang>(parser_type.GetTypeSystem());
   if (ast == nullptr)
     return false;
 
   if (m_parser_vars->m_materializer && is_result) {
     Status err;
 
     ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
     Target *target = exe_ctx.GetTargetPtr();
     if (target == nullptr)
       return false;
 
-    auto *clang_ast_context = ClangASTContext::GetScratch(*target);
+    auto *clang_ast_context = TypeSystemClang::GetScratch(*target);
     if (!clang_ast_context)
       return false;
 
     TypeFromUser user_type = DeportType(*clang_ast_context, *ast, parser_type);
 
     uint32_t offset = m_parser_vars->m_materializer->AddResultVariable(
         user_type, is_lvalue, m_keep_result_in_memory, m_result_delegate, err);
 
bool ClangExpressionDeclMap::AddPersistentVariable(const NamedDecl *decl,
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
   ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
   Target *target = exe_ctx.GetTargetPtr();
   if (target == nullptr)
     return false;
 
-  ClangASTContext *context = ClangASTContext::GetScratch(*target);
+  TypeSystemClang *context = TypeSystemClang::GetScratch(*target);
   if (!context)
     return false;
 
   TypeFromUser user_type = DeportType(*context, *ast, parser_type);
 
   if (!user_type.GetOpaqueQualType()) {
     LLDB_LOGF(log, "Persistent variable's type wasn't copied successfully");
     return false;
lldb::VariableSP ClangExpressionDeclMap::FindGlobalVariable(
   else
     target.GetImages().FindGlobalVariables(name, -1, vars);
 
   if (vars.GetSize() == 0)
     return VariableSP();
   return vars.GetVariableAtIndex(0);
 }
 
-ClangASTContext *ClangExpressionDeclMap::GetClangASTContext() {
+TypeSystemClang *ClangExpressionDeclMap::GetTypeSystemClang() {
   StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
   if (frame == nullptr)
     return nullptr;
 
   SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
                                                   lldb::eSymbolContextBlock);
   if (sym_ctx.block == nullptr)
     return nullptr;
 
   CompilerDeclContext frame_decl_context = sym_ctx.block->GetDeclContext();
   if (!frame_decl_context)
     return nullptr;
 
-  return llvm::dyn_cast_or_null<ClangASTContext>(
+  return llvm::dyn_cast_or_null<TypeSystemClang>(
       frame_decl_context.GetTypeSystem());
 }
 
 // Interface for ClangASTSource
 
 void ClangExpressionDeclMap::FindExternalVisibleDecls(
     NameSearchContext &context) {
   assert(m_ast_context);

 
 clang::NamedDecl *ClangExpressionDeclMap::GetPersistentDecl(ConstString name) {
   if (!m_parser_vars)
     return nullptr;
   Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
   if (!target)
     return nullptr;
 
-  ClangASTContext::GetScratch(*target);
+  TypeSystemClang::GetScratch(*target);
 
   if (!m_parser_vars->m_persistent_vars)
     return nullptr;
   return m_parser_vars->m_persistent_vars->GetPersistentDecl(name);
 }
 
 void ClangExpressionDeclMap::SearchPersistenDecls(NameSearchContext &context,
                                                   const ConstString name,
if (!function_block)
     return;
 
   CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
 
   if (!function_decl_ctx)
     return;
 
   clang::CXXMethodDecl *method_decl =
-      ClangASTContext::DeclContextGetAsCXXMethodDecl(function_decl_ctx);
+      TypeSystemClang::DeclContextGetAsCXXMethodDecl(function_decl_ctx);
 
   if (method_decl) {
     clang::CXXRecordDecl *class_decl = method_decl->getParent();
 
     QualType class_qual_type(class_decl->getTypeForDecl(), 0);
 
     TypeFromUser class_user_type(class_qual_type.getAsOpaquePtr(),
                                  function_decl_ctx.GetTypeSystem());
if (!function_block)
     return;
 
   CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
 
   if (!function_decl_ctx)
     return;
 
   clang::ObjCMethodDecl *method_decl =
-      ClangASTContext::DeclContextGetAsObjCMethodDecl(function_decl_ctx);
+      TypeSystemClang::DeclContextGetAsObjCMethodDecl(function_decl_ctx);
 
   if (method_decl) {
     ObjCInterfaceDecl *self_interface = method_decl->getClassInterface();
 
     if (!self_interface)
       return;
 
     const clang::Type *interface_type = self_interface->getTypeForDecl();
void ClangExpressionDeclMap::LookUpLldbObjCClass(NameSearchContext &context,
 
   Type *self_type = self_var->GetType();
 
   if (!self_type)
     return;
 
   CompilerType self_clang_type = self_type->GetFullCompilerType();
 
-  if (ClangASTContext::IsObjCClassType(self_clang_type)) {
+  if (TypeSystemClang::IsObjCClassType(self_clang_type)) {
     return;
   }
-  if (!ClangASTContext::IsObjCObjectPointerType(self_clang_type))
+  if (!TypeSystemClang::IsObjCObjectPointerType(self_clang_type))
     return;
   self_clang_type = self_clang_type.GetPointeeType();
 
   if (!self_clang_type)
     return;
 
   LLDB_LOG(log, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}",
            current_id, ClangUtil::ToString(self_type->GetFullCompilerType()));
void ClangExpressionDeclMap::LookupLocalVarNamespace(
     SymbolContext &sym_ctx, NameSearchContext &name_context) {
   if (sym_ctx.block == nullptr)
     return;
 
   CompilerDeclContext frame_decl_context = sym_ctx.block->GetDeclContext();
   if (!frame_decl_context)
     return;
 
-  ClangASTContext *frame_ast = llvm::dyn_cast_or_null<ClangASTContext>(
+  TypeSystemClang *frame_ast = llvm::dyn_cast_or_null<TypeSystemClang>(
       frame_decl_context.GetTypeSystem());
   if (!frame_ast)
     return;
 
   clang::NamespaceDecl *namespace_decl =
       m_clang_ast_context->GetUniqueNamespaceDeclaration(
           g_lldb_local_vars_namespace_cstr, nullptr);
   if (!namespace_decl)
SymbolContextList ClangExpressionDeclMap::SearchFunctionsInSymbolContexts(
   // compare and prune into a separate list. Cache the info needed about
   // the function declarations in a vector for efficiency.
   uint32_t num_indices = sc_list.GetSize();
   SymbolContextList sc_sym_list;
   std::vector<FuncDeclInfo> decl_infos;
   decl_infos.reserve(num_indices);
   clang::DeclContext *frame_decl_ctx =
       (clang::DeclContext *)frame_decl_context.GetOpaqueDeclContext();
-  ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(
+  TypeSystemClang *ast = llvm::dyn_cast_or_null<TypeSystemClang>(
       frame_decl_context.GetTypeSystem());
 
   for (uint32_t index = 0; index < num_indices; ++index) {
     FuncDeclInfo fdi;
     SymbolContext sym_ctx;
     sc_list.GetContextAtIndex(index, sym_ctx);
 
     // We don't know enough about symbols to compare them, but we should
bool ClangExpressionDeclMap::GetVariableValue(VariableSP &var,
   CompilerType var_clang_type = var_type->GetFullCompilerType();
 
   if (!var_clang_type) {
     if (log)
       log->PutCString("Skipped a definition because it has no Clang type");
     return false;
   }
 
-  ClangASTContext *clang_ast = llvm::dyn_cast_or_null<ClangASTContext>(
+  TypeSystemClang *clang_ast = llvm::dyn_cast_or_null<TypeSystemClang>(
       var_type->GetForwardCompilerType().GetTypeSystem());
 
   if (!clang_ast) {
     if (log)
       log->PutCString("Skipped a definition because it has no Clang AST");
     return false;
   }
 
void ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
 
   if (target == nullptr)
     return;
 
-  ClangASTContext *scratch_ast_context = ClangASTContext::GetScratch(*target);
+  TypeSystemClang *scratch_ast_context = TypeSystemClang::GetScratch(*target);
   if (!scratch_ast_context)
     return;
 
   TypeFromUser user_type(scratch_ast_context->GetBasicType(eBasicTypeVoid)
                              .GetPointerType()
                              .GetLValueReferenceType());
   TypeFromParser parser_type(m_clang_ast_context->GetBasicType(eBasicTypeVoid)
                                  .GetPointerType()
if (function) {
     const auto name = function->GetMangled().GetMangledName().AsCString();
     const bool extern_c = (Language::LanguageIsC(lang) &&
                            !CPlusPlusLanguage::IsCPPMangledName(name)) ||
                           (Language::LanguageIsObjC(lang) &&
                            !Language::LanguageIsCPlusPlus(lang));
 
     if (!extern_c) {
       TypeSystem *type_system = function->GetDeclContext().GetTypeSystem();
-      if (llvm::isa<ClangASTContext>(type_system)) {
+      if (llvm::isa<TypeSystemClang>(type_system)) {
         clang::DeclContext *src_decl_context =
             (clang::DeclContext *)function->GetDeclContext()
                 .GetOpaqueDeclContext();
         clang::FunctionDecl *src_function_decl =
             llvm::dyn_cast_or_null<clang::FunctionDecl>(src_decl_context);
         if (src_function_decl &&
             src_function_decl->getTemplateSpecializationInfo()) {
           clang::FunctionTemplateDecl *function_template =

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

private:
   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;
+  std::unique_ptr<TypeSystemClang> m_ast_context;
 
   std::vector<std::string> m_include_directories;
   /// File name used for the user expression.
   std::string m_filename;
 };
 }
 
 #endif // liblldb_ClangExpressionParser_h_

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

 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRInterpreter.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/LLDBAssert.h"
ClangExpressionParser::ClangExpressionParser(
   auto &PP = m_compiler->getPreprocessor();
   auto &builtin_context = PP.getBuiltinInfo();
   builtin_context.initializeBuiltins(PP.getIdentifierTable(),
                                      m_compiler->getLangOpts());
 
   m_compiler->createASTContext();
   clang::ASTContext &ast_context = m_compiler->getASTContext();
 
-  m_ast_context.reset(new ClangASTContext(
+  m_ast_context.reset(new TypeSystemClang(
       "Expression ASTContext for '" + m_filename + "'", ast_context));
 
   std::string module_name("$__lldb_module");
 
   m_llvm_context.reset(new LLVMContext());
   m_code_generator.reset(CreateLLVMCodeGen(
       m_compiler->getDiagnostics(), module_name,
       m_compiler->getHeaderSearchOpts(), m_compiler->getPreprocessorOpts(),

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

 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/IR/Module.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"

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

 
 #include "ClangHost.h"
 #include "ClangModulesDeclVendor.h"
 #include "ModuleDependencyCollector.h"
 
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SourceModule.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/StreamString.h"
private:
   size_t m_source_location_index =
       0; // used to give name components fake SourceLocations
 
   typedef std::vector<ConstString> ImportedModule;
   typedef std::map<ImportedModule, clang::Module *> ImportedModuleMap;
   typedef std::set<ModuleID> ImportedModuleSet;
   ImportedModuleMap m_imported_modules;
   ImportedModuleSet m_user_imported_modules;
-  // We assume that every ASTContext has an ClangASTContext, so we also store
-  // a custom ClangASTContext for our internal ASTContext.
-  std::unique_ptr<ClangASTContext> m_ast_context;
+  // We assume that every ASTContext has an TypeSystemClang, so we also store
+  // a custom TypeSystemClang for our internal ASTContext.
+  std::unique_ptr<TypeSystemClang> m_ast_context;
 };
 } // anonymous namespace
 
 StoringDiagnosticConsumer::StoringDiagnosticConsumer() {
   m_log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
 }
 
 void StoringDiagnosticConsumer::HandleDiagnostic(
ClangModulesDeclVendorImpl::ClangModulesDeclVendorImpl(
     std::shared_ptr<clang::CompilerInvocation> compiler_invocation,
     std::unique_ptr<clang::CompilerInstance> compiler_instance,
     std::unique_ptr<clang::Parser> parser)
     : m_diagnostics_engine(std::move(diagnostics_engine)),
       m_compiler_invocation(std::move(compiler_invocation)),
       m_compiler_instance(std::move(compiler_instance)),
       m_parser(std::move(parser)) {
 
-  // Initialize our ClangASTContext.
+  // Initialize our TypeSystemClang.
   m_ast_context.reset(
-      new ClangASTContext("ClangModulesDeclVendor ASTContext",
+      new TypeSystemClang("ClangModulesDeclVendor ASTContext",
                           m_compiler_instance->getASTContext()));
 }
 
 void ClangModulesDeclVendorImpl::ReportModuleExportsHelper(
     std::set<ClangModulesDeclVendor::ModuleID> &exports,
     clang::Module *module) {
   if (exports.count(reinterpret_cast<ClangModulesDeclVendor::ModuleID>(module)))
     return;

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

std::string GetNextExprFileName() {
     name.append(">");
     return name;
   }
 
   llvm::Optional<CompilerType>
   GetCompilerTypeFromPersistentDecl(ConstString type_name) override;
 
   void RegisterPersistentDecl(ConstString name, clang::NamedDecl *decl,
-                              ClangASTContext *ctx);
+                              TypeSystemClang *ctx);
 
   clang::NamedDecl *GetPersistentDecl(ConstString name);
 
   void AddHandLoadedClangModule(ClangModulesDeclVendor::ModuleID module) {
     m_hand_loaded_clang_modules.push_back(module);
   }
 
   const ClangModulesDeclVendor::ModuleVector &GetHandLoadedClangModules() {
     return m_hand_loaded_clang_modules;
   }
 
 private:
   /// The counter used by GetNextExprFileName.
   uint32_t m_next_user_file_id = 0;
   // The counter used by GetNextPersistentVariableName
   uint32_t m_next_persistent_variable_id = 0;
 
   struct PersistentDecl {
     /// The persistent decl.
     clang::NamedDecl *m_decl = nullptr;
-    /// The ClangASTContext for the ASTContext of m_decl.
-    ClangASTContext *m_context = nullptr;
+    /// The TypeSystemClang for the ASTContext of m_decl.
+    TypeSystemClang *m_context = nullptr;
   };
 
   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.
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ClangPersistentVariables_h_

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

 //===-- ClangPersistentVariables.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 "ClangPersistentVariables.h"
 
 #include "lldb/Core/Value.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "clang/AST/Decl.h"
 
 #include "llvm/ADT/StringMap.h"
opaque_compiler_type_t t = static_cast<opaque_compiler_type_t>(
         const_cast<clang::Type *>(tdecl->getTypeForDecl()));
     return CompilerType(p.m_context, t);
   }
   return llvm::None;
 }
 
 void ClangPersistentVariables::RegisterPersistentDecl(ConstString name,
                                                       clang::NamedDecl *decl,
-                                                      ClangASTContext *ctx) {
+                                                      TypeSystemClang *ctx) {
   PersistentDecl p = {decl, ctx};
   m_persistent_decls.insert(std::make_pair(name.GetCString(), p));
 
   if (clang::EnumDecl *enum_decl = llvm::dyn_cast<clang::EnumDecl>(decl)) {
     for (clang::EnumConstantDecl *enumerator_decl : enum_decl->enumerators()) {
       p = {enumerator_decl, ctx};
       m_persistent_decls.insert(std::make_pair(
           ConstString(enumerator_decl->getNameAsString()).GetCString(), p));
     }
   }
 }
 
 clang::NamedDecl *
 ClangPersistentVariables::GetPersistentDecl(ConstString name) {
   return m_persistent_decls.lookup(name.GetCString()).m_decl;
 }

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

 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Expression/ExpressionSourceCode.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRInterpreter.h"
 #include "lldb/Expression/Materializer.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/Block.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangASTMetadata.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/VariableList.h"
if (m_ctx_obj) {
     case lldb::eLanguageTypeObjC_plus_plus:
       m_in_objectivec_method = true;
       break;
     default:
       break;
     }
     m_needs_object_ptr = true;
   } else if (clang::CXXMethodDecl *method_decl =
-          ClangASTContext::DeclContextGetAsCXXMethodDecl(decl_context)) {
+          TypeSystemClang::DeclContextGetAsCXXMethodDecl(decl_context)) {
     if (m_allow_cxx && method_decl->isInstance()) {
       if (m_enforce_valid_object) {
         lldb::VariableListSP variable_list_sp(
             function_block->GetBlockVariableList(true));
 
         const char *thisErrorString = "Stopped in a C++ method, but 'this' "
                                       "isn't available; pretending we are in a "
                                       "generic context";
if (m_allow_cxx && method_decl->isInstance()) {
           return;
         }
       }
 
       m_in_cplusplus_method = true;
       m_needs_object_ptr = true;
     }
   } else if (clang::ObjCMethodDecl *method_decl =
-                 ClangASTContext::DeclContextGetAsObjCMethodDecl(
+                 TypeSystemClang::DeclContextGetAsObjCMethodDecl(
                      decl_context)) {
     if (m_allow_objc) {
       if (m_enforce_valid_object) {
         lldb::VariableListSP variable_list_sp(
             function_block->GetBlockVariableList(true));
 
         const char *selfErrorString = "Stopped in an Objective-C method, but "
                                       "'self' isn't available; pretending we "
if (m_allow_objc) {
 
       m_in_objectivec_method = true;
       m_needs_object_ptr = true;
 
       if (!method_decl->isInstanceMethod())
         m_in_static_method = true;
     }
   } else if (clang::FunctionDecl *function_decl =
-                 ClangASTContext::DeclContextGetAsFunctionDecl(decl_context)) {
+                 TypeSystemClang::DeclContextGetAsFunctionDecl(decl_context)) {
     // We might also have a function that said in the debug information that it
     // captured an object pointer.  The best way to deal with getting to the
     // ivars at present is by pretending that this is a method of a class in
     // whatever runtime the debug info says the object pointer belongs to.  Do
     // that here.
 
     ClangASTMetadata *metadata =
-        ClangASTContext::DeclContextGetMetaData(decl_context, function_decl);
+        TypeSystemClang::DeclContextGetMetaData(decl_context, function_decl);
     if (metadata && metadata->HasObjectPtr()) {
       lldb::LanguageType language = metadata->GetObjectPtrLanguage();
       if (language == lldb::eLanguageTypeC_plus_plus) {
         if (m_enforce_valid_object) {
           lldb::VariableListSP variable_list_sp(
               function_block->GetBlockVariableList(true));
 
           const char *thisErrorString = "Stopped in a context claiming to "
if (metadata && metadata->HasObjectPtr()) {
 
           CompilerType self_clang_type = self_type->GetForwardCompilerType();
 
           if (!self_clang_type) {
             err.SetErrorString(selfErrorString);
             return;
           }
 
-          if (ClangASTContext::IsObjCClassType(self_clang_type)) {
+          if (TypeSystemClang::IsObjCClassType(self_clang_type)) {
             return;
-          } else if (ClangASTContext::IsObjCObjectPointerType(
+          } else if (TypeSystemClang::IsObjCObjectPointerType(
                          self_clang_type)) {
             m_in_objectivec_method = true;
             m_needs_object_ptr = true;
           } else {
             err.SetErrorString(selfErrorString);
             return;
           }
         } else {

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

 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/IPO.h"
 
 #include "clang/AST/ASTContext.h"
 
 #include "lldb/Core/dwarf.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRInterpreter.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/StreamString.h"
if (m_result_is_pointer) {
     const clang::ObjCObjectPointerType *pointer_objcobjpointertype =
         pointer_type->getAs<clang::ObjCObjectPointerType>();
 
     if (pointer_pointertype) {
       clang::QualType element_qual_type = pointer_pointertype->getPointeeType();
 
       m_result_type = lldb_private::TypeFromParser(
           element_qual_type.getAsOpaquePtr(),
-          lldb_private::ClangASTContext::GetASTContext(
+          lldb_private::TypeSystemClang::GetASTContext(
               &result_decl->getASTContext()));
     } else if (pointer_objcobjpointertype) {
       clang::QualType element_qual_type =
           clang::QualType(pointer_objcobjpointertype->getObjectType(), 0);
 
       m_result_type = lldb_private::TypeFromParser(
           element_qual_type.getAsOpaquePtr(),
-          lldb_private::ClangASTContext::GetASTContext(
+          lldb_private::TypeSystemClang::GetASTContext(
               &result_decl->getASTContext()));
     } else {
       LLDB_LOG(log, "Expected result to have pointer type, but it did not");
 
       m_error_stream.Format("Internal error [IRForTarget]: Lvalue result ({0}) "
                             "is not a pointer variable\n",
                             result_name);
 
       return false;
     }
   } else {
     m_result_type = lldb_private::TypeFromParser(
         result_var->getType().getAsOpaquePtr(),
-        lldb_private::ClangASTContext::GetASTContext(
+        lldb_private::TypeSystemClang::GetASTContext(
             &result_decl->getASTContext()));
   }
 
   lldb::TargetSP target_sp(m_execution_unit.GetTarget());
   lldb_private::ExecutionContext exe_ctx(target_sp, true);
   llvm::Optional<uint64_t> bit_size =
       m_result_type.GetBitSize(exe_ctx.GetBestExecutionContextScope());
   if (!bit_size) {
bool IRForTarget::RewritePersistentAlloc(llvm::Instruction *persistent_alloc) {
   // We attempt to register this as a new persistent variable with the DeclMap.
 
   uintptr_t ptr = constant_int->getZExtValue();
 
   clang::VarDecl *decl = reinterpret_cast<clang::VarDecl *>(ptr);
 
   lldb_private::TypeFromParser result_decl_type(
       decl->getType().getAsOpaquePtr(),
-      lldb_private::ClangASTContext::GetASTContext(&decl->getASTContext()));
+      lldb_private::TypeSystemClang::GetASTContext(&decl->getASTContext()));
 
   StringRef decl_name(decl->getName());
   lldb_private::ConstString persistent_variable_name(decl_name.data(),
                                                      decl_name.size());
   if (!m_decl_map->AddPersistentVariable(decl, persistent_variable_name,
                                          result_decl_type, false, false))
     return false;
 
if (ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(llvm_value_ptr)) {
 
     llvm::StringRef name(named_decl->getName());
 
     clang::ValueDecl *value_decl = dyn_cast<clang::ValueDecl>(named_decl);
     if (value_decl == nullptr)
       return false;
 
     lldb_private::CompilerType compiler_type(
-        lldb_private::ClangASTContext::GetASTContext(
+        lldb_private::TypeSystemClang::GetASTContext(
             &value_decl->getASTContext()),
         value_decl->getType().getAsOpaquePtr());
 
     const Type *value_type = nullptr;
 
     if (name.startswith("$")) {
       // The $__lldb_expr_result name indicates the return value has allocated
       // as a static variable.  Per the comment at

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

 //===-- BlockPointer.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 "BlockPointer.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Target.h"
 
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 
if (!target_sp) {
       return;
     }
 
     auto type_system_or_err = target_sp->GetScratchTypeSystemForLanguage(
         lldb::eLanguageTypeC_plus_plus);
     if (auto err = type_system_or_err.takeError()) {
       LLDB_LOG_ERROR(
           lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS),
-          std::move(err), "Failed to get scratch ClangASTContext");
+          std::move(err), "Failed to get scratch TypeSystemClang");
       return;
     }
 
-    ClangASTContext *clang_ast_context =
-        llvm::dyn_cast<ClangASTContext>(&type_system_or_err.get());
+    TypeSystemClang *clang_ast_context =
+        llvm::dyn_cast<TypeSystemClang>(&type_system_or_err.get());
 
     if (!clang_ast_context) {
       return;
     }
 
     ClangASTImporterSP clang_ast_importer = target_sp->GetClangASTImporter();
 
     if (!clang_ast_importer) {

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

 #include "llvm/Support/ConvertUTF.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/Host/Time.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"

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

 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/DataFormatters/VectorIterator.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
if (m_pair_ptr) {
       if (!pair_type) {
         m_pair_ptr = nullptr;
         return false;
       }
 
       auto addr(m_pair_ptr->GetValueAsUnsigned(LLDB_INVALID_ADDRESS));
       m_pair_ptr = nullptr;
       if (addr && addr != LLDB_INVALID_ADDRESS) {
-        ClangASTContext *ast_ctx =
-            llvm::dyn_cast_or_null<ClangASTContext>(pair_type.GetTypeSystem());
+        TypeSystemClang *ast_ctx =
+            llvm::dyn_cast_or_null<TypeSystemClang>(pair_type.GetTypeSystem());
         if (!ast_ctx)
           return false;
         CompilerType tree_node_type = ast_ctx->CreateStructForIdentifier(
             ConstString(),
             {{"ptr0",
               ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
              {"ptr1",
               ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
if (summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryCapped) {
     if (size > max_size) {
       size = max_size;
       options.SetIsTruncated(true);
     }
   }
   location_sp->GetPointeeData(extractor, 0, size);
 
   // std::wstring::size() is measured in 'characters', not bytes
-  ClangASTContext *ast_context =
-      ClangASTContext::GetScratch(*valobj.GetTargetSP());
+  TypeSystemClang *ast_context =
+      TypeSystemClang::GetScratch(*valobj.GetTargetSP());
   if (!ast_context)
     return false;
 
   auto wchar_t_size =
       ast_context->GetBasicType(lldb::eBasicTypeWChar).GetByteSize(nullptr);
   if (!wchar_t_size)
     return false;
 

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

 //===-- LibCxxBitset.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 "LibCxx.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 
 class BitsetFrontEnd : public SyntheticChildrenFrontEnd {

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

 //===-- LibCxxList.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 "LibCxx.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;

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

 //===-- LibCxxMap.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 "LibCxx.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
void lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetValueOffset(
   if (!node)
     return;
   CompilerType node_type(node->GetCompilerType());
   uint64_t bit_offset;
   if (node_type.GetIndexOfFieldWithName("__value_", nullptr, &bit_offset) !=
       UINT32_MAX) {
     m_skip_size = bit_offset / 8u;
   } else {
-    ClangASTContext *ast_ctx =
-        llvm::dyn_cast_or_null<ClangASTContext>(node_type.GetTypeSystem());
+    TypeSystemClang *ast_ctx =
+        llvm::dyn_cast_or_null<TypeSystemClang>(node_type.GetTypeSystem());
     if (!ast_ctx)
       return;
     CompilerType tree_node_type = ast_ctx->CreateStructForIdentifier(
         ConstString(),
         {{"ptr0", ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
          {"ptr1", ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
          {"ptr2", ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
          {"cw", ast_ctx->GetBasicType(lldb::eBasicTypeBool)},

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

 //===-- LibCxxUnorderedMap.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 "LibCxx.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;

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

 //===-- LibStdcpp.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 "LibStdcpp.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/VectorIterator.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;

lldb/source/Plugins/Language/ObjC/CF.cpp

 //===-- CF.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 "CF.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 

lldb/source/Plugins/Language/ObjC/Cocoa.cpp

 
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/Host/Time.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"

lldb/source/Plugins/Language/ObjC/NSArray.cpp

 #include "Cocoa.h"
 
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Expression/FunctionCaller.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
bool lldb_private::formatters::NSArraySummaryProvider(
   return true;
 }
 
 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::NSArrayMSyntheticFrontEndBase(
     lldb::ValueObjectSP valobj_sp)
     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
       m_id_type() {
   if (valobj_sp) {
-    auto *clang_ast_context = ClangASTContext::GetScratch(
+    auto *clang_ast_context = TypeSystemClang::GetScratch(
         *valobj_sp->GetExecutionContextRef().GetTargetSP());
     if (clang_ast_context)
       m_id_type = CompilerType(
           clang_ast_context,
           clang_ast_context->getASTContext().ObjCBuiltinIdTy.getAsOpaquePtr());
     if (valobj_sp->GetProcessSP())
       m_ptr_size = valobj_sp->GetProcessSP()->GetAddressByteSize();
   }

 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
   GenericNSArrayISyntheticFrontEnd(
     lldb::ValueObjectSP valobj_sp)
     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
       m_data_32(nullptr), m_data_64(nullptr) {
   if (valobj_sp) {
     CompilerType type = valobj_sp->GetCompilerType();
     if (type) {
-      auto *clang_ast_context = ClangASTContext::GetScratch(
+      auto *clang_ast_context = TypeSystemClang::GetScratch(
           *valobj_sp->GetExecutionContextRef().GetTargetSP());
       if (clang_ast_context)
         m_id_type = clang_ast_context->GetType(
             clang_ast_context->getASTContext().ObjCBuiltinIdTy);
     }
   }
 }
 

 
 lldb::ValueObjectSP
 lldb_private::formatters::NSArray1SyntheticFrontEnd::GetChildAtIndex(
     size_t idx) {
   static const ConstString g_zero("[0]");
 
   if (idx == 0) {
     auto *clang_ast_context =
-        ClangASTContext::GetScratch(*m_backend.GetTargetSP());
+        TypeSystemClang::GetScratch(*m_backend.GetTargetSP());
     if (clang_ast_context) {
       CompilerType id_type(
           clang_ast_context->GetBasicType(lldb::eBasicTypeObjCID));
       return m_backend.GetSyntheticChildAtOffset(
           m_backend.GetProcessSP()->GetAddressByteSize(), id_type, true,
           g_zero);
     }
   }

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

 
 #include "NSDictionary.h"
 
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
NSDictionary_Additionals::GetAdditionalSynthetics() {
   static AdditionalFormatters<CXXSyntheticChildren::CreateFrontEndCallback>
       g_map;
   return g_map;
 }
 
 static CompilerType GetLLDBNSPairType(TargetSP target_sp) {
   CompilerType compiler_type;
 
-  ClangASTContext *target_ast_context = ClangASTContext::GetScratch(*target_sp);
+  TypeSystemClang *target_ast_context = TypeSystemClang::GetScratch(*target_sp);
 
   if (target_ast_context) {
     ConstString g___lldb_autogen_nspair("__lldb_autogen_nspair");
 
     compiler_type =
         target_ast_context->GetTypeForIdentifier<clang::CXXRecordDecl>(
             g___lldb_autogen_nspair);
 
     if (!compiler_type) {
       compiler_type = target_ast_context->CreateRecordType(
           nullptr, lldb::eAccessPublic, g___lldb_autogen_nspair.GetCString(),
           clang::TTK_Struct, lldb::eLanguageTypeC);
 
       if (compiler_type) {
-        ClangASTContext::StartTagDeclarationDefinition(compiler_type);
+        TypeSystemClang::StartTagDeclarationDefinition(compiler_type);
         CompilerType id_compiler_type =
             target_ast_context->GetBasicType(eBasicTypeObjCID);
-        ClangASTContext::AddFieldToRecordType(
+        TypeSystemClang::AddFieldToRecordType(
             compiler_type, "key", id_compiler_type, lldb::eAccessPublic, 0);
-        ClangASTContext::AddFieldToRecordType(
+        TypeSystemClang::AddFieldToRecordType(
             compiler_type, "value", id_compiler_type, lldb::eAccessPublic, 0);
-        ClangASTContext::CompleteTagDeclarationDefinition(compiler_type);
+        TypeSystemClang::CompleteTagDeclarationDefinition(compiler_type);
       }
     }
   }
   return compiler_type;
 }
 
 namespace lldb_private {
 namespace formatters {

lldb/source/Plugins/Language/ObjC/NSError.cpp

 //===-- NSError.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/DeclCXX.h"
 
 #include "Cocoa.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 #include "Plugins/Language/ObjC/NSString.h"
if (!domain_str_value) {
     return true;
   }
 
   InferiorSizedWord isw(domain_str_value, *process_sp);
 
   ValueObjectSP domain_str_sp = ValueObject::CreateValueObjectFromData(
       "domain_str", isw.GetAsData(process_sp->GetByteOrder()),
       valobj.GetExecutionContextRef(),
-      ClangASTContext::GetScratch(process_sp->GetTarget())
+      TypeSystemClang::GetScratch(process_sp->GetTarget())
           ->GetBasicType(lldb::eBasicTypeVoid)
           .GetPointerType());
 
   if (!domain_str_sp)
     return false;
 
   StreamString domain_str_summary;
   if (NSStringSummaryProvider(*domain_str_sp, domain_str_summary, options) &&
bool Update() override {
     lldb::addr_t userinfo =
         process_sp->ReadPointerFromMemory(userinfo_location, error);
     if (userinfo == LLDB_INVALID_ADDRESS || error.Fail())
       return false;
     InferiorSizedWord isw(userinfo, *process_sp);
     m_child_sp = CreateValueObjectFromData(
         "_userInfo", isw.GetAsData(process_sp->GetByteOrder()),
         m_backend.GetExecutionContextRef(),
-        ClangASTContext::GetScratch(process_sp->GetTarget())
+        TypeSystemClang::GetScratch(process_sp->GetTarget())
             ->GetBasicType(lldb::eBasicTypeObjCID));
     return false;
   }
 
   bool MightHaveChildren() override { return true; }
 
   size_t GetIndexOfChildWithName(ConstString name) override {
     static ConstString g___userInfo("_userInfo");

lldb/source/Plugins/Language/ObjC/NSException.cpp

 //===-- NSException.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/DeclCXX.h"
 
 #include "Cocoa.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 #include "Plugins/Language/ObjC/NSString.h"
static bool ExtractFields(ValueObject &valobj, ValueObjectSP *name_sp,
   if (error.Fail() || reserved == LLDB_INVALID_ADDRESS)
     return false;
 
   InferiorSizedWord name_isw(name, *process_sp);
   InferiorSizedWord reason_isw(reason, *process_sp);
   InferiorSizedWord userinfo_isw(userinfo, *process_sp);
   InferiorSizedWord reserved_isw(reserved, *process_sp);
 
-  auto *clang_ast_context = ClangASTContext::GetScratch(process_sp->GetTarget());
+  auto *clang_ast_context = TypeSystemClang::GetScratch(process_sp->GetTarget());
   if (!clang_ast_context)
     return false;
 
   CompilerType voidstar =
       clang_ast_context->GetBasicType(lldb::eBasicTypeVoid).GetPointerType();
 
   if (name_sp)
     *name_sp = ValueObject::CreateValueObjectFromData(

lldb/source/Plugins/Language/ObjC/NSIndexPath.cpp

 //===-- NSIndexPath.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 "Cocoa.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/TypeSynthetic.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
public:
 
   bool Update() override {
     m_impl.Clear();
 
     TypeSystem *type_system = m_backend.GetCompilerType().GetTypeSystem();
     if (!type_system)
       return false;
 
-    ClangASTContext *ast = ClangASTContext::GetScratch(
+    TypeSystemClang *ast = TypeSystemClang::GetScratch(
         *m_backend.GetExecutionContextRef().GetTargetSP());
     if (!ast)
       return false;
 
     m_uint_star_type = ast->GetPointerSizedIntType(false);
 
     static ConstString g__indexes("_indexes");
     static ConstString g__length("_length");

lldb/source/Plugins/Language/ObjC/NSSet.cpp

 //===-- NSSet.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 "NSSet.h"
 
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;

lldb/source/Plugins/Language/ObjC/NSString.cpp

 //===-- NSString.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 "NSString.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/StringPrinter.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 std::map<ConstString, CXXFunctionSummaryFormat::Callback> &
 NSString_Additionals::GetAdditionalSummaries() {
   static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map;
   return g_map;
 }
 
 static CompilerType GetNSPathStore2Type(Target &target) {
   static ConstString g_type_name("__lldb_autogen_nspathstore2");
 
-  ClangASTContext *ast_ctx = ClangASTContext::GetScratch(target);
+  TypeSystemClang *ast_ctx = TypeSystemClang::GetScratch(target);
 
   if (!ast_ctx)
     return CompilerType();
 
   CompilerType voidstar =
       ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType();
   CompilerType uint32 =
       ast_ctx->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);

lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp

 //===-- ObjCLanguage.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 <mutex>
 
 #include "ObjCLanguage.h"
 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/Threading.h"
 

lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp

 #include "llvm/ADT/StringRef.h"
 
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/UniqueCStringMap.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Target/ThreadPlanStepInRange.h"

lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
if (!target.GetSectionLoadList().IsEmpty()) {
             if (class_types.Empty()) {
               LLDB_LOGF(log, "0x%16.16" PRIx64 ": is not dynamic\n",
                         original_ptr);
               return TypeAndOrName();
             }
             if (class_types.GetSize() == 1) {
               type_sp = class_types.GetTypeAtIndex(0);
               if (type_sp) {
-                if (ClangASTContext::IsCXXClassType(
+                if (TypeSystemClang::IsCXXClassType(
                         type_sp->GetForwardCompilerType())) {
                   LLDB_LOGF(
                       log,
                       "0x%16.16" PRIx64
                       ": static-type = '%s' has dynamic type: uid={0x%" PRIx64
                       "}, type-name='%s'\n",
                       original_ptr, in_value.GetTypeName().AsCString(),
                       type_sp->GetID(), type_sp->GetName().GetCString());
if (!target.GetSectionLoadList().IsEmpty()) {
                         type_sp->GetID(), type_sp->GetName().GetCString());
                   }
                 }
               }
 
               for (i = 0; i < class_types.GetSize(); i++) {
                 type_sp = class_types.GetTypeAtIndex(i);
                 if (type_sp) {
-                  if (ClangASTContext::IsCXXClassType(
+                  if (TypeSystemClang::IsCXXClassType(
                           type_sp->GetForwardCompilerType())) {
                     LLDB_LOGF(
                         log,
                         "0x%16.16" PRIx64 ": static-type = '%s' has multiple "
                         "matching dynamic types, picking "
                         "this one: uid={0x%" PRIx64 "}, type-name='%s'\n",
                         original_ptr, in_value.GetTypeName().AsCString(),
                         type_sp->GetID(), type_sp->GetName().GetCString());
bool ItaniumABILanguageRuntime::GetDynamicTypeAndAddress(
   CompilerType type = class_type_or_name.GetCompilerType();
   // There can only be one type with a given name, so we've just found
   // duplicate definitions, and this one will do as well as any other. We
   // don't consider something to have a dynamic type if it is the same as
   // the static type.  So compare against the value we were handed.
   if (!type)
     return true;
 
-  if (ClangASTContext::AreTypesSame(in_value.GetCompilerType(), type)) {
+  if (TypeSystemClang::AreTypesSame(in_value.GetCompilerType(), type)) {
     // The dynamic type we found was the same type, so we don't have a
     // dynamic type here...
     return false;
   }
 
   // The offset_to_top is two pointers above the vtable pointer.
   const uint32_t addr_byte_size = process->GetAddressByteSize();
   const lldb::addr_t offset_to_top_location =
return m_process->GetBreakpointSiteList().BreakpointSiteContainsBreakpoint(
       break_site_id, m_cxx_exception_bp_sp->GetID());
 }
 
 ValueObjectSP ItaniumABILanguageRuntime::GetExceptionObjectForThread(
     ThreadSP thread_sp) {
   if (!thread_sp->SafeToCallFunctions())
     return {};
 
-  ClangASTContext *clang_ast_context =
-      ClangASTContext::GetScratch(m_process->GetTarget());
+  TypeSystemClang *clang_ast_context =
+      TypeSystemClang::GetScratch(m_process->GetTarget());
   if (!clang_ast_context)
     return {};
 
   CompilerType voidstar =
       clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
 
   DiagnosticManager diagnostics;
   ExecutionContext exe_ctx;

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.h

 //===-- AppleObjCDeclVendor.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_AppleObjCDeclVendor_h_
 #define liblldb_AppleObjCDeclVendor_h_
 
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/lldb-private.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangDeclVendor.h"
 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
 
 namespace lldb_private {
 
 class AppleObjCExternalASTSource;
public:
 
   friend class AppleObjCExternalASTSource;
 
 private:
   clang::ObjCInterfaceDecl *GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa);
   bool FinishDecl(clang::ObjCInterfaceDecl *decl);
 
   ObjCLanguageRuntime &m_runtime;
-  ClangASTContext m_ast_ctx;
+  TypeSystemClang m_ast_ctx;
   ObjCLanguageRuntime::EncodingToTypeSP m_type_realizer_sp;
   AppleObjCExternalASTSource *m_external_source;
 
   typedef llvm::DenseMap<ObjCLanguageRuntime::ObjCISA,
                          clang::ObjCInterfaceDecl *>
       ISAToInterfaceMap;
 
   ISAToInterfaceMap m_isa_to_interface;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_AppleObjCDeclVendor_h_

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp

while (true) {
           return;
         }
       } break;
       }
     }
   }
 
   clang::ObjCMethodDecl *
-  BuildMethod(ClangASTContext &clang_ast_ctxt,
+  BuildMethod(TypeSystemClang &clang_ast_ctxt,
               clang::ObjCInterfaceDecl *interface_decl, const char *name,
               bool instance,
               ObjCLanguageRuntime::EncodingToTypeSP type_realizer_sp) {
     if (!m_is_valid || m_type_vector.size() < 3)
       return nullptr;
 
     clang::ASTContext &ast_ctx(interface_decl->getASTContext());
 

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
bool AppleObjCRuntime::GetObjectDescription(Stream &strm, Value &value,
   // Get the function address for the print function.
   const Address *function_address = GetPrintForDebuggerAddr();
   if (!function_address)
     return false;
 
   Target *target = exe_ctx.GetTargetPtr();
   CompilerType compiler_type = value.GetCompilerType();
   if (compiler_type) {
-    if (!ClangASTContext::IsObjCObjectPointerType(compiler_type)) {
+    if (!TypeSystemClang::IsObjCObjectPointerType(compiler_type)) {
       strm.Printf("Value doesn't point to an ObjC object.\n");
       return false;
     }
   } else {
     // If it is not a pointer, see if we can make it into a pointer.
-    ClangASTContext *ast_context = ClangASTContext::GetScratch(*target);
+    TypeSystemClang *ast_context = TypeSystemClang::GetScratch(*target);
     if (!ast_context)
       return false;
 
     CompilerType opaque_type = ast_context->GetBasicType(eBasicTypeObjCID);
     if (!opaque_type)
       opaque_type = ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
     // value.SetContext(Value::eContextTypeClangType, opaque_type_ptr);
     value.SetCompilerType(opaque_type);
   }
 
   ValueList arg_value_list;
   arg_value_list.PushValue(value);
 
   // This is the return value:
-  ClangASTContext *ast_context = ClangASTContext::GetScratch(*target);
+  TypeSystemClang *ast_context = TypeSystemClang::GetScratch(*target);
   if (!ast_context)
     return false;
 
   CompilerType return_compiler_type = ast_context->GetCStringType(true);
   Value ret;
   //    ret.SetContext(Value::eContextTypeClangType, return_compiler_type);
   ret.SetCompilerType(return_compiler_type);
 
ThreadSP AppleObjCRuntime::GetBacktraceThreadFromException(
     lldb::ValueObjectSP exception_sp) {
   ValueObjectSP reserved_dict =
       exception_sp->GetChildMemberWithName(ConstString("reserved"), true);
   if (!reserved_dict) return ThreadSP();
 
   reserved_dict = reserved_dict->GetSyntheticValue();
   if (!reserved_dict) return ThreadSP();
 
-  ClangASTContext *clang_ast_context =
-      ClangASTContext::GetScratch(*exception_sp->GetTargetSP());
+  TypeSystemClang *clang_ast_context =
+      TypeSystemClang::GetScratch(*exception_sp->GetTargetSP());
   if (!clang_ast_context)
     return ThreadSP();
   CompilerType objc_id =
       clang_ast_context->GetBasicType(lldb::eBasicTypeObjCID);
   ValueObjectSP return_addresses;
 
   auto objc_object_from_address = [&exception_sp, &objc_id](uint64_t addr,
                                                             const char *name) {

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

 
 #include "clang/AST/Type.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
AppleObjCRuntimeV2::UpdateISAToDescriptorMapDynamic(
   ExecutionContext exe_ctx;
 
   ThreadSP thread_sp = process->GetThreadList().GetExpressionExecutionThread();
 
   if (!thread_sp)
     return DescriptorMapUpdateResult::Fail();
 
   thread_sp->CalculateExecutionContext(exe_ctx);
-  ClangASTContext *ast = ClangASTContext::GetScratch(process->GetTarget());
+  TypeSystemClang *ast = TypeSystemClang::GetScratch(process->GetTarget());
 
   if (!ast)
     return DescriptorMapUpdateResult::Fail();
 
   Address function_address;
 
   DiagnosticManager diagnostics;
 
AppleObjCRuntimeV2::UpdateISAToDescriptorMapSharedCache() {
   ExecutionContext exe_ctx;
 
   ThreadSP thread_sp = process->GetThreadList().GetExpressionExecutionThread();
 
   if (!thread_sp)
     return DescriptorMapUpdateResult::Fail();
 
   thread_sp->CalculateExecutionContext(exe_ctx);
-  ClangASTContext *ast = ClangASTContext::GetScratch(process->GetTarget());
+  TypeSystemClang *ast = TypeSystemClang::GetScratch(process->GetTarget());
 
   if (!ast)
     return DescriptorMapUpdateResult::Fail();
 
   Address function_address;
 
   DiagnosticManager diagnostics;
 

  public:
   ObjCExceptionRecognizedStackFrame(StackFrameSP frame_sp) {
     ThreadSP thread_sp = frame_sp->GetThread();
     ProcessSP process_sp = thread_sp->GetProcess();
 
     const lldb::ABISP &abi = process_sp->GetABI();
     if (!abi) return;
 
-    ClangASTContext *clang_ast_context =
-        ClangASTContext::GetScratch(process_sp->GetTarget());
+    TypeSystemClang *clang_ast_context =
+        TypeSystemClang::GetScratch(process_sp->GetTarget());
     if (!clang_ast_context)
       return;
     CompilerType voidstar =
         clang_ast_context->GetBasicType(lldb::eBasicTypeVoid).GetPointerType();
 
     ValueList args;
     Value input_value;
     input_value.SetCompilerType(voidstar);

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Expression/UtilityFunction.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
if (vtable_handler->InitializeVTableSymbols()) {
     // The Update function is called with the address of an added region.  So we
     // grab that address, and
     // feed it into ReadRegions.  Of course, our friend the ABI will get the
     // values for us.
     ExecutionContext exe_ctx(context->exe_ctx_ref);
     Process *process = exe_ctx.GetProcessPtr();
     const ABI *abi = process->GetABI().get();
 
-    ClangASTContext *clang_ast_context =
-        ClangASTContext::GetScratch(process->GetTarget());
+    TypeSystemClang *clang_ast_context =
+        TypeSystemClang::GetScratch(process->GetTarget());
     if (!clang_ast_context)
       return false;
 
     ValueList argument_values;
     Value input_value;
     CompilerType clang_void_ptr_type =
         clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
 
if (!m_impl_code) {
           return args_addr;
         }
       } else {
         LLDB_LOGF(log, "No method lookup implementation code.");
         return LLDB_INVALID_ADDRESS;
       }
 
       // Next make the runner function for our implementation utility function.
-      ClangASTContext *clang_ast_context =
-          ClangASTContext::GetScratch(thread.GetProcess()->GetTarget());
+      TypeSystemClang *clang_ast_context =
+          TypeSystemClang::GetScratch(thread.GetProcess()->GetTarget());
       if (!clang_ast_context)
         return LLDB_INVALID_ADDRESS;
 
       CompilerType clang_void_ptr_type =
           clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
       Status error;
 
       impl_function_caller = m_impl_code->MakeFunctionCaller(
if (found_it) {
     ProcessSP process_sp(thread.CalculateProcess());
     if (process_sp)
       abi = process_sp->GetABI().get();
     if (abi == nullptr)
       return ret_plan_sp;
 
     TargetSP target_sp(thread.CalculateTarget());
 
-    ClangASTContext *clang_ast_context = ClangASTContext::GetScratch(*target_sp);
+    TypeSystemClang *clang_ast_context = TypeSystemClang::GetScratch(*target_sp);
     if (!clang_ast_context)
       return ret_plan_sp;
 
     ValueList argument_values;
     Value void_ptr_value;
     CompilerType clang_void_ptr_type =
         clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
     void_ptr_value.SetValueType(Value::eValueTypeScalar);

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.h

 
 namespace lldb_private {
 class StringLexer;
 class AppleObjCTypeEncodingParser : public ObjCLanguageRuntime::EncodingToType {
 public:
   AppleObjCTypeEncodingParser(ObjCLanguageRuntime &runtime);
   ~AppleObjCTypeEncodingParser() override = default;
 
-  CompilerType RealizeType(ClangASTContext &ast_ctx, const char *name,
+  CompilerType RealizeType(TypeSystemClang &ast_ctx, const char *name,
                            bool for_expression) override;
 
 private:
   struct StructElement {
     std::string name;
     clang::QualType type;
     uint32_t bitfield;
 
     StructElement();
     ~StructElement() = default;
   };
 
-  clang::QualType BuildType(ClangASTContext &clang_ast_ctx, StringLexer &type,
+  clang::QualType BuildType(TypeSystemClang &clang_ast_ctx, StringLexer &type,
                             bool for_expression,
                             uint32_t *bitfield_bit_size = nullptr);
 
-  clang::QualType BuildStruct(ClangASTContext &ast_ctx, StringLexer &type,
+  clang::QualType BuildStruct(TypeSystemClang &ast_ctx, StringLexer &type,
                               bool for_expression);
 
-  clang::QualType BuildAggregate(ClangASTContext &clang_ast_ctx,
+  clang::QualType BuildAggregate(TypeSystemClang &clang_ast_ctx,
                                  StringLexer &type, bool for_expression,
                                  char opener, char closer, uint32_t kind);
 
-  clang::QualType BuildUnion(ClangASTContext &ast_ctx, StringLexer &type,
+  clang::QualType BuildUnion(TypeSystemClang &ast_ctx, StringLexer &type,
                              bool for_expression);
 
-  clang::QualType BuildArray(ClangASTContext &ast_ctx, StringLexer &type,
+  clang::QualType BuildArray(TypeSystemClang &ast_ctx, StringLexer &type,
                              bool for_expression);
 
   std::string ReadStructName(StringLexer &type);
 
-  StructElement ReadStructElement(ClangASTContext &ast_ctx, StringLexer &type,
+  StructElement ReadStructElement(TypeSystemClang &ast_ctx, StringLexer &type,
                                   bool for_expression);
 
-  clang::QualType BuildObjCObjectPointerType(ClangASTContext &clang_ast_ctx,
+  clang::QualType BuildObjCObjectPointerType(TypeSystemClang &clang_ast_ctx,
                                              StringLexer &type,
                                              bool for_expression);
 
   uint32_t ReadNumber(StringLexer &type);
 
   std::string ReadQuotedString(StringLexer &type);
 
   ObjCLanguageRuntime &m_runtime;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_AppleObjCTypeEncodingParser_h_

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp

 //===-- AppleObjCTypeEncodingParser.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 "AppleObjCTypeEncodingParser.h"
 
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/StringLexer.h"
 
 #include <vector>
 
 using namespace lldb_private;
 
 AppleObjCTypeEncodingParser::AppleObjCTypeEncodingParser(
     ObjCLanguageRuntime &runtime)
     : ObjCLanguageRuntime::EncodingToType(), m_runtime(runtime) {
   if (!m_scratch_ast_ctx_up)
-    m_scratch_ast_ctx_up.reset(new ClangASTContext(
+    m_scratch_ast_ctx_up.reset(new TypeSystemClang(
         "AppleObjCTypeEncodingParser ASTContext",
         runtime.GetProcess()->GetTarget().GetArchitecture().GetTriple()));
 }
 
 std::string AppleObjCTypeEncodingParser::ReadStructName(StringLexer &type) {
   StreamString buffer;
   while (type.HasAtLeast(1) && type.Peek() != '=')
     buffer.Printf("%c", type.Next());

 // as an extension to the published grammar recent runtimes emit structs like
 // this:
 // "{CGRect=\"origin\"{CGPoint=\"x\"d\"y\"d}\"size\"{CGSize=\"width\"d\"height\"d}}"
 
 AppleObjCTypeEncodingParser::StructElement::StructElement()
     : name(""), type(clang::QualType()), bitfield(0) {}
 
 AppleObjCTypeEncodingParser::StructElement
-AppleObjCTypeEncodingParser::ReadStructElement(ClangASTContext &ast_ctx,
+AppleObjCTypeEncodingParser::ReadStructElement(TypeSystemClang &ast_ctx,
                                                StringLexer &type,
                                                bool for_expression) {
   StructElement retval;
   if (type.NextIf('"'))
     retval.name = ReadQuotedString(type);
   if (!type.NextIf('"'))
     return retval;
   uint32_t bitfield_size = 0;
   retval.type = BuildType(ast_ctx, type, for_expression, &bitfield_size);
   retval.bitfield = bitfield_size;
   return retval;
 }
 
 clang::QualType AppleObjCTypeEncodingParser::BuildStruct(
-    ClangASTContext &ast_ctx, StringLexer &type, bool for_expression) {
+    TypeSystemClang &ast_ctx, StringLexer &type, bool for_expression) {
   return BuildAggregate(ast_ctx, type, for_expression, '{', '}',
                         clang::TTK_Struct);
 }
 
 clang::QualType AppleObjCTypeEncodingParser::BuildUnion(
-    ClangASTContext &ast_ctx, StringLexer &type, bool for_expression) {
+    TypeSystemClang &ast_ctx, StringLexer &type, bool for_expression) {
   return BuildAggregate(ast_ctx, type, for_expression, '(', ')',
                         clang::TTK_Union);
 }
 
 clang::QualType AppleObjCTypeEncodingParser::BuildAggregate(
-    ClangASTContext &ast_ctx, StringLexer &type, bool for_expression,
+    TypeSystemClang &ast_ctx, StringLexer &type, bool for_expression,
     char opener, char closer, uint32_t kind) {
   if (!type.NextIf(opener))
     return clang::QualType();
   std::string name(ReadStructName(type));
 
   // We do not handle templated classes/structs at the moment. If the name has
   // a < in it, we are going to abandon this. We're still obliged to parse it,
   // so we just set a flag that means "Don't actually build anything."
if (in_union)
     return clang::QualType();
 
   if (is_templated)
     return clang::QualType(); // This is where we bail out.  Sorry!
 
   CompilerType union_type(ast_ctx.CreateRecordType(
       nullptr, lldb::eAccessPublic, name, kind, lldb::eLanguageTypeC));
   if (union_type) {
-    ClangASTContext::StartTagDeclarationDefinition(union_type);
+    TypeSystemClang::StartTagDeclarationDefinition(union_type);
 
     unsigned int count = 0;
     for (auto element : elements) {
       if (element.name.empty()) {
         StreamString elem_name;
         elem_name.Printf("__unnamed_%u", count);
         element.name = elem_name.GetString();
       }
-      ClangASTContext::AddFieldToRecordType(
+      TypeSystemClang::AddFieldToRecordType(
           union_type, element.name.c_str(), ast_ctx.GetType(element.type),
           lldb::eAccessPublic, element.bitfield);
       ++count;
     }
-    ClangASTContext::CompleteTagDeclarationDefinition(union_type);
+    TypeSystemClang::CompleteTagDeclarationDefinition(union_type);
   }
   return ClangUtil::GetQualType(union_type);
 }
 
 clang::QualType AppleObjCTypeEncodingParser::BuildArray(
-    ClangASTContext &ast_ctx, StringLexer &type, bool for_expression) {
+    TypeSystemClang &ast_ctx, StringLexer &type, bool for_expression) {
   if (!type.NextIf('['))
     return clang::QualType();
   uint32_t size = ReadNumber(type);
   clang::QualType element_type(BuildType(ast_ctx, type, for_expression));
   if (!type.NextIf(']'))
     return clang::QualType();
   CompilerType array_type(ast_ctx.CreateArrayType(
       CompilerType(&ast_ctx, element_type.getAsOpaquePtr()), size, false));
   return ClangUtil::GetQualType(array_type);
 }
 
 // the runtime can emit these in the form of @"SomeType", giving more specifics
 // this would be interesting for expression parser interop, but since we
 // actually try to avoid exposing the ivar info to the expression evaluator,
 // consume but ignore the type info and always return an 'id'; if anything,
 // dynamic typing will resolve things for us anyway
 clang::QualType AppleObjCTypeEncodingParser::BuildObjCObjectPointerType(
-    ClangASTContext &clang_ast_ctx, StringLexer &type, bool for_expression) {
+    TypeSystemClang &clang_ast_ctx, StringLexer &type, bool for_expression) {
   if (!type.NextIf('@'))
     return clang::QualType();
 
   clang::ASTContext &ast_ctx = clang_ast_ctx.getASTContext();
 
   std::string name;
 
   if (type.NextIf('"')) {
#endif
     return ClangUtil::GetQualType(types.front().GetPointerType());
   } else {
     // We're going to resolve this dynamically anyway, so just smile and wave.
     return ast_ctx.getObjCIdType();
   }
 }
 
 clang::QualType
-AppleObjCTypeEncodingParser::BuildType(ClangASTContext &clang_ast_ctx,
+AppleObjCTypeEncodingParser::BuildType(TypeSystemClang &clang_ast_ctx,
                                        StringLexer &type, bool for_expression,
                                        uint32_t *bitfield_bit_size) {
   if (!type.HasAtLeast(1))
     return clang::QualType();
 
   clang::ASTContext &ast_ctx = clang_ast_ctx.getASTContext();
 
   switch (type.Peek()) {
if (!for_expression && type.NextIf('?')) {
         return ast_ctx.getPointerType(target_type);
     }
   }
   case '?':
     return for_expression ? ast_ctx.UnknownAnyTy : clang::QualType();
   }
 }
 
-CompilerType AppleObjCTypeEncodingParser::RealizeType(ClangASTContext &ast_ctx,
+CompilerType AppleObjCTypeEncodingParser::RealizeType(TypeSystemClang &ast_ctx,
                                                       const char *name,
                                                       bool for_expression) {
   if (name && name[0]) {
     StringLexer lexer(name);
     clang::QualType qual_type = BuildType(ast_ctx, lexer, for_expression);
     return ast_ctx.GetType(qual_type);
   }
   return CompilerType();
 }

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

private:
     LazyBool m_is_cf;
     lldb::TypeWP m_type_wp;
   };
 
   class EncodingToType {
   public:
     virtual ~EncodingToType();
 
-    virtual CompilerType RealizeType(ClangASTContext &ast_ctx, const char *name,
+    virtual CompilerType RealizeType(TypeSystemClang &ast_ctx, const char *name,
                                      bool for_expression) = 0;
     virtual CompilerType RealizeType(const char *name, bool for_expression);
 
   protected:
-    std::unique_ptr<ClangASTContext> m_scratch_ast_ctx_up;
+    std::unique_ptr<TypeSystemClang> m_scratch_ast_ctx_up;
   };
 
   class ObjCExceptionPrecondition : public BreakpointPrecondition {
   public:
     ObjCExceptionPrecondition();
 
     ~ObjCExceptionPrecondition() override = default;
 

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

 //===-- ObjCLanguageRuntime.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/Type.h"
 
 #include "ObjCLanguageRuntime.h"
 
 #include "lldb/Core/MappedHash.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObject.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Timer.h"
if (matching_symbols) {
 
     llvm::DenseSet<SymbolFile *> searched_symbol_files;
     module_sp->FindTypes(name, exact_match, max_matches, searched_symbol_files,
                          types);
 
     for (uint32_t i = 0; i < types.GetSize(); ++i) {
       TypeSP type_sp(types.GetTypeAtIndex(i));
 
-      if (ClangASTContext::IsObjCObjectOrInterfaceType(
+      if (TypeSystemClang::IsObjCObjectOrInterfaceType(
               type_sp->GetForwardCompilerType())) {
         if (type_sp->IsCompleteObjCClass()) {
           m_complete_class_cache[name] = type_sp;
           return type_sp;
         }
       }
     }
   }
Status ObjCLanguageRuntime::ObjCExceptionPrecondition::ConfigurePrecondition(
   return error;
 }
 
 llvm::Optional<CompilerType>
 ObjCLanguageRuntime::GetRuntimeType(CompilerType base_type) {
   CompilerType class_type;
   bool is_pointer_type = false;
 
-  if (ClangASTContext::IsObjCObjectPointerType(base_type, &class_type))
+  if (TypeSystemClang::IsObjCObjectPointerType(base_type, &class_type))
     is_pointer_type = true;
-  else if (ClangASTContext::IsObjCObjectOrInterfaceType(base_type))
+  else if (TypeSystemClang::IsObjCObjectOrInterfaceType(base_type))
     class_type = base_type;
   else
     return llvm::None;
 
   if (!class_type)
     return llvm::None;
 
   ConstString class_name(class_type.GetConstTypeName());

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileCache.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
if (!dlopen_utility_func_up->Install(diagnostics, exe_ctx)) {
     return nullptr;
   }
 
   Value value;
   ValueList arguments;
   FunctionCaller *do_dlopen_function = nullptr;
 
   // Fetch the clang types we will need:
-  ClangASTContext *ast = ClangASTContext::GetScratch(process->GetTarget());
+  TypeSystemClang *ast = TypeSystemClang::GetScratch(process->GetTarget());
   if (!ast)
     return nullptr;
 
   CompilerType clang_void_pointer_type
       = ast->GetBasicType(eBasicTypeVoid).GetPointerType();
   CompilerType clang_char_pointer_type
         = ast->GetBasicType(eBasicTypeChar).GetPointerType();
 
uint32_t PlatformPOSIX::DoLoadImage(lldb_private::Process *process,
   options.SetUnwindOnError(true);
   options.SetTrapExceptions(false); // dlopen can't throw exceptions, so
                                     // don't do the work to trap them.
   options.SetTimeout(process->GetUtilityExpressionTimeout());
   options.SetIsForUtilityExpr(true);
 
   Value return_value;
   // Fetch the clang types we will need:
-  ClangASTContext *ast = ClangASTContext::GetScratch(process->GetTarget());
+  TypeSystemClang *ast = TypeSystemClang::GetScratch(process->GetTarget());
   if (!ast) {
-    error.SetErrorString("dlopen error: Unable to get ClangASTContext");
+    error.SetErrorString("dlopen error: Unable to get TypeSystemClang");
     return LLDB_INVALID_IMAGE_TOKEN;
   }
 
   CompilerType clang_void_pointer_type
       = ast->GetBasicType(eBasicTypeVoid).GetPointerType();
 
   return_value.SetCompilerType(clang_void_pointer_type);
   

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

 
 #include "DWARFASTParser.h"
 #include "DWARFDIE.h"
 #include "DWARFDefines.h"
 #include "DWARFFormValue.h"
 #include "LogChannelDWARF.h"
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/PluginInterface.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 
 #include <vector>
 
 namespace lldb_private {
 class CompileUnit;
 }
 class DWARFDebugInfoEntry;
 class SymbolFileDWARF;
 
 struct ParsedDWARFTypeAttributes;
 
 class DWARFASTParserClang : public DWARFASTParser {
 public:
-  DWARFASTParserClang(lldb_private::ClangASTContext &ast);
+  DWARFASTParserClang(lldb_private::TypeSystemClang &ast);
 
   ~DWARFASTParserClang() override;
 
   // DWARFASTParser interface.
   lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
                                   const DWARFDIE &die,
                                   bool *type_is_new_ptr) override;
 
protected:
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *>
       DIEToDeclContextMap;
   typedef std::multimap<const clang::DeclContext *, const DWARFDIE>
       DeclContextToDIEMap;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *>
       DIEToDeclMap;
   typedef llvm::DenseMap<const clang::Decl *, DIEPointerSet> DeclToDIEMap;
 
-  lldb_private::ClangASTContext &m_ast;
+  lldb_private::TypeSystemClang &m_ast;
   DIEToDeclMap m_die_to_decl;
   DeclToDIEMap m_decl_to_die;
   DIEToDeclContextMap m_die_to_decl_ctx;
   DeclContextToDIEMap m_decl_ctx_to_die;
   std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_up;
   /// @}
 
   clang::DeclContext *GetDeclContextForBlock(const DWARFDIE &die);
 
   clang::BlockDecl *ResolveBlockDIE(const DWARFDIE &die);
 
   clang::NamespaceDecl *ResolveNamespaceDIE(const DWARFDIE &die);
 
   bool ParseTemplateDIE(const DWARFDIE &die,
-                        lldb_private::ClangASTContext::TemplateParameterInfos
+                        lldb_private::TypeSystemClang::TemplateParameterInfos
                             &template_param_infos);
   bool ParseTemplateParameterInfos(
       const DWARFDIE &parent_die,
-      lldb_private::ClangASTContext::TemplateParameterInfos
+      lldb_private::TypeSystemClang::TemplateParameterInfos
           &template_param_infos);
 
   bool ParseChildMembers(
       const DWARFDIE &die, lldb_private::CompilerType &class_compiler_type,
       const lldb::LanguageType class_language,
       std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
       std::vector<int> &member_accessibilities,
       std::vector<DWARFDIE> &member_function_dies,

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 #include <stdio.h>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
-DWARFASTParserClang::DWARFASTParserClang(ClangASTContext &ast)
+DWARFASTParserClang::DWARFASTParserClang(TypeSystemClang &ast)
     : m_ast(ast), m_die_to_decl_ctx(), m_decl_ctx_to_die() {}
 
 DWARFASTParserClang::~DWARFASTParserClang() {}
 
 static AccessType DW_ACCESS_to_AccessType(uint32_t dwarf_accessibility) {
   switch (dwarf_accessibility) {
   case DW_ACCESS_public:
     return eAccessPublic;
TypeSP DWARFASTParserClang::ParseTypeFromClangModule(const SymbolContext &sc,
   SymbolFileDWARF *dwarf = die.GetDWARF();
   TypeSP type_sp(new Type(
       die.GetID(), dwarf, pcm_type_sp->GetName(), pcm_type_sp->GetByteSize(),
       nullptr, LLDB_INVALID_UID, Type::eEncodingInvalid,
       &pcm_type_sp->GetDeclaration(), type, Type::ResolveState::Forward));
 
   dwarf->GetTypeList().Insert(type_sp);
   dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
-  clang::TagDecl *tag_decl = ClangASTContext::GetAsTagDecl(type);
+  clang::TagDecl *tag_decl = TypeSystemClang::GetAsTagDecl(type);
   if (tag_decl)
     LinkDeclContextToDIE(tag_decl, die);
   else {
     clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(die);
     if (defn_decl_ctx)
       LinkDeclContextToDIE(defn_decl_ctx, die);
   }
 
   return type_sp;
 }
 
-static void CompleteExternalTagDeclType(ClangASTContext &ast,
+static void CompleteExternalTagDeclType(TypeSystemClang &ast,
                                         ClangASTImporter &ast_importer,
                                         clang::DeclContext *decl_ctx,
                                         DWARFDIE die,
                                         const char *type_name_cstr) {
   auto *tag_decl_ctx = clang::dyn_cast<clang::TagDecl>(decl_ctx);
   if (!tag_decl_ctx)
     return;
 
   // If this type was not imported from an external AST, there's nothing to do.
   CompilerType type = ast.GetTypeForDecl(tag_decl_ctx);
   if (!type || !ast_importer.CanImport(type))
     return;
 
   auto qual_type = ClangUtil::GetQualType(type);
   if (!ast_importer.RequireCompleteType(qual_type)) {
     die.GetDWARF()->GetObjectFile()->GetModule()->ReportError(
         "Unable to complete the Decl context for DIE '%s' at offset "
         "0x%8.8x.\nPlease file a bug report.",
         type_name_cstr ? type_name_cstr : "", die.GetOffset());
     // We need to make the type look complete otherwise, we might crash in
     // Clang when adding children.
-    if (ClangASTContext::StartTagDeclarationDefinition(type))
-      ClangASTContext::CompleteTagDeclarationDefinition(type);
+    if (TypeSystemClang::StartTagDeclarationDefinition(type))
+      TypeSystemClang::CompleteTagDeclarationDefinition(type);
   }
 }
 
 ParsedDWARFTypeAttributes::ParsedDWARFTypeAttributes(const DWARFDIE &die) {
   DWARFAttributes attributes;
   size_t num_attributes = die.GetAttributes(attributes);
   for (size_t i = 0; i < num_attributes; ++i) {
     dw_attr_t attr = attributes.AttributeAtIndex(i);
if (!clang_type) {
     clang_type = m_ast.CreateEnumerationType(
         attrs.name.GetCString(), GetClangDeclContextContainingDIE(die, nullptr),
         attrs.decl, enumerator_clang_type, attrs.is_scoped_enum);
   } else {
     enumerator_clang_type =
         m_ast.GetEnumerationIntegerType(clang_type.GetOpaqueQualType());
   }
 
-  LinkDeclContextToDIE(ClangASTContext::GetDeclContextForType(clang_type), die);
+  LinkDeclContextToDIE(TypeSystemClang::GetDeclContextForType(clang_type), die);
 
   type_sp = std::make_shared<Type>(
       die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
       dwarf->GetUID(attrs.type.Reference()), Type::eEncodingIsUID, &attrs.decl,
       clang_type, Type::ResolveState::Forward);
 
-  if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) {
+  if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
     if (die.HasChildren()) {
       bool is_signed = false;
       enumerator_clang_type.IsIntegerType(is_signed);
       ParseChildEnumerators(clang_type, is_signed,
                             type_sp->GetByteSize().getValueOr(0), die);
     }
-    ClangASTContext::CompleteTagDeclarationDefinition(clang_type);
+    TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
   } else {
     dwarf->GetObjectFile()->GetModule()->ReportError(
         "DWARF DIE at 0x%8.8x named \"%s\" was not able to start its "
         "definition.\nPlease file a bug and attach the file at the "
         "start of this error message",
         die.GetOffset(), attrs.name.GetCString());
   }
   return type_sp;
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
         if (class_name) {
           TypeSP complete_objc_class_type_sp(
               dwarf->FindCompleteObjCDefinitionTypeForDIE(DWARFDIE(),
                                                           class_name, false));
 
           if (complete_objc_class_type_sp) {
             CompilerType type_clang_forward_type =
                 complete_objc_class_type_sp->GetForwardCompilerType();
-            if (ClangASTContext::IsObjCObjectOrInterfaceType(
+            if (TypeSystemClang::IsObjCObjectOrInterfaceType(
                     type_clang_forward_type))
               class_opaque_type = type_clang_forward_type;
           }
         }
 
         if (class_opaque_type) {
           // If accessibility isn't set to anything valid, assume public
           // for now...
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
                   "0x%8.8" PRIx64 ": DW_AT_abstract_origin(0x%8.8x"
                   ") has no decl\n",
                   die.GetID(), abs_die.GetOffset());
             }
             type_handled = true;
           } else {
             CompilerType class_opaque_type =
                 class_type->GetForwardCompilerType();
-            if (ClangASTContext::IsCXXClassType(class_opaque_type)) {
+            if (TypeSystemClang::IsCXXClassType(class_opaque_type)) {
               if (class_opaque_type.IsBeingDefined() || alternate_defn) {
                 if (!is_static && !die.HasChildren()) {
                   // We have a C++ member function with no children (this
                   // pointer!) and clang will get mad if we try and make
                   // a function that isn't well formed in the DWARF, so
                   // we will just skip it...
                   type_handled = true;
                 } else {
if (!type_handled) {
         // We just have a function that isn't part of a class
         function_decl = m_ast.CreateFunctionDeclaration(
             ignore_containing_context ? m_ast.GetTranslationUnitDecl()
                                       : containing_decl_ctx,
             attrs.name.GetCString(), clang_type, attrs.storage,
             attrs.is_inline);
 
         if (has_template_params) {
-          ClangASTContext::TemplateParameterInfos template_param_infos;
+          TypeSystemClang::TemplateParameterInfos template_param_infos;
           ParseTemplateParameterInfos(die, template_param_infos);
           template_function_decl = m_ast.CreateFunctionDeclaration(
               ignore_containing_context ? m_ast.GetTranslationUnitDecl()
                                         : containing_decl_ctx,
               attrs.name.GetCString(), clang_type, attrs.storage,
               attrs.is_inline);
           clang::FunctionTemplateDecl *func_template_decl =
               m_ast.CreateFunctionTemplateDecl(
TypeSP DWARFASTParserClang::ParseArrayType(const DWARFDIE &die,
   if (array_info) {
     attrs.byte_stride = array_info->byte_stride;
     attrs.bit_stride = array_info->bit_stride;
   }
   if (attrs.byte_stride == 0 && attrs.bit_stride == 0)
     attrs.byte_stride = element_type->GetByteSize().getValueOr(0);
   CompilerType array_element_type = element_type->GetForwardCompilerType();
 
-  if (ClangASTContext::IsCXXClassType(array_element_type) &&
+  if (TypeSystemClang::IsCXXClassType(array_element_type) &&
       !array_element_type.GetCompleteType()) {
     ModuleSP module_sp = die.GetModule();
     if (module_sp) {
       if (die.GetCU()->GetProducer() == eProducerClang)
         module_sp->ReportError(
             "DWARF DW_TAG_array_type DIE at 0x%8.8x has a "
             "class/union/struct element type DIE 0x%8.8x that is a "
             "forward declaration, not a complete definition.\nTry "
if (module_sp) {
             die.GetOffset(), type_die.GetOffset(), GetUnitName(die).c_str());
     }
 
     // We have no choice other than to pretend that the element class
     // type is complete. If we don't do this, clang will crash when
     // trying to layout the class. Since we provide layout
     // assistance, all ivars in this class and other classes will be
     // fine, this is the best we can do short of crashing.
-    if (ClangASTContext::StartTagDeclarationDefinition(array_element_type)) {
-      ClangASTContext::CompleteTagDeclarationDefinition(array_element_type);
+    if (TypeSystemClang::StartTagDeclarationDefinition(array_element_type)) {
+      TypeSystemClang::CompleteTagDeclarationDefinition(array_element_type);
     } else {
       module_sp->ReportError("DWARF DIE at 0x%8.8x was not able to "
                              "start its definition.\nPlease file a "
                              "bug and attach the file at the start "
                              "of this error message",
                              type_die.GetOffset());
     }
   }
TypeSP DWARFASTParserClang::ParsePointerToMemberType(
   SymbolFileDWARF *dwarf = die.GetDWARF();
   Type *pointee_type = dwarf->ResolveTypeUID(attrs.type.Reference(), true);
   Type *class_type =
       dwarf->ResolveTypeUID(attrs.containing_type.Reference(), true);
 
   CompilerType pointee_clang_type = pointee_type->GetForwardCompilerType();
   CompilerType class_clang_type = class_type->GetLayoutCompilerType();
 
-  CompilerType clang_type = ClangASTContext::CreateMemberPointerType(
+  CompilerType clang_type = TypeSystemClang::CreateMemberPointerType(
       class_clang_type, pointee_clang_type);
 
   if (llvm::Optional<uint64_t> clang_type_size =
           clang_type.GetByteSize(nullptr)) {
     return std::make_shared<Type>(die.GetID(), dwarf, attrs.name,
                                   *clang_type_size, nullptr, LLDB_INVALID_UID,
                                   Type::eEncodingIsUID, nullptr, clang_type,
                                   Type::ResolveState::Forward);
if (attrs.accessibility == eAccessNone && decl_ctx) {
         attrs.accessibility = default_accessibility;
     }
 
     ClangASTMetadata metadata;
     metadata.SetUserID(die.GetID());
     metadata.SetIsDynamicCXXType(dwarf->ClassOrStructIsVirtual(die));
 
     if (attrs.name.GetStringRef().contains('<')) {
-      ClangASTContext::TemplateParameterInfos template_param_infos;
+      TypeSystemClang::TemplateParameterInfos template_param_infos;
       if (ParseTemplateParameterInfos(die, template_param_infos)) {
         clang::ClassTemplateDecl *class_template_decl =
             m_ast.ParseClassTemplateDecl(decl_ctx, attrs.accessibility,
                                          attrs.name.GetCString(), tag_decl_kind,
                                          template_param_infos);
         if (!class_template_decl) {
           if (log) {
             dwarf->GetObjectFile()->GetModule()->LogMessage(
DWARFASTParserClang::ParseStructureLikeDIE(const SymbolContext &sc,
 
   if (!attrs.is_forward_declaration) {
     // Always start the definition for a class type so that if the class
     // has child classes or types that require the class to be created
     // for use as their decl contexts the class will be ready to accept
     // these child definitions.
     if (!die.HasChildren()) {
       // No children for this struct/union/class, lets finish it
-      if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) {
-        ClangASTContext::CompleteTagDeclarationDefinition(clang_type);
+      if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
+        TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
       } else {
         dwarf->GetObjectFile()->GetModule()->ReportError(
             "DWARF DIE at 0x%8.8x named \"%s\" was not able to start its "
             "definition.\nPlease file a bug and attach the file at the "
             "start of this error message",
             die.GetOffset(), attrs.name.GetCString());
       }
 
       if (tag == DW_TAG_structure_type) // this only applies in C
       {
         clang::RecordDecl *record_decl =
-            ClangASTContext::GetAsRecordDecl(clang_type);
+            TypeSystemClang::GetAsRecordDecl(clang_type);
 
         if (record_decl) {
           GetClangASTImporter().SetRecordLayout(
               record_decl, ClangASTImporter::LayoutInfo());
         }
       }
     } else if (clang_type_was_created) {
       // Start the definition if the class is not objective C since the
       // underlying decls respond to isCompleteDefinition(). Objective
       // C decls don't respond to isCompleteDefinition() so we can't
       // start the declaration definition right away. For C++
       // class/union/structs we want to start the definition in case the
       // class is needed as the declaration context for a contained class
       // or type without the need to complete that type..
 
       if (attrs.class_language != eLanguageTypeObjC &&
           attrs.class_language != eLanguageTypeObjC_plus_plus)
-        ClangASTContext::StartTagDeclarationDefinition(clang_type);
+        TypeSystemClang::StartTagDeclarationDefinition(clang_type);
 
       // Leave this as a forward declaration until we need to know the
       // details of the type. lldb_private::Type will automatically call
       // the SymbolFile virtual function
       // "SymbolFileDWARF::CompleteType(Type *)" When the definition
       // needs to be defined.
       assert(!dwarf->GetForwardDeclClangTypeToDie().count(
                  ClangUtil::RemoveFastQualifiers(clang_type)
operator=(const DelayedAddObjCClassProperty &rhs) {
     if (rhs.m_metadata_up) {
       m_metadata_up.reset(new ClangASTMetadata());
       *m_metadata_up = *rhs.m_metadata_up;
     }
     return *this;
   }
 
   bool Finalize() {
-    return ClangASTContext::AddObjCClassProperty(
+    return TypeSystemClang::AddObjCClassProperty(
         m_class_opaque_type, m_property_name, m_property_opaque_type,
         m_ivar_decl, m_property_setter_name, m_property_getter_name,
         m_property_attributes, m_metadata_up.get());
   }
 
 private:
   CompilerType m_class_opaque_type;
   const char *m_property_name;
   CompilerType m_property_opaque_type;
   clang::ObjCIvarDecl *m_ivar_decl;
   const char *m_property_setter_name;
   const char *m_property_getter_name;
   uint32_t m_property_attributes;
   std::unique_ptr<ClangASTMetadata> m_metadata_up;
 };
 
 bool DWARFASTParserClang::ParseTemplateDIE(
     const DWARFDIE &die,
-    ClangASTContext::TemplateParameterInfos &template_param_infos) {
+    TypeSystemClang::TemplateParameterInfos &template_param_infos) {
   const dw_tag_t tag = die.Tag();
   bool is_template_template_argument = false;
 
   switch (tag) {
   case DW_TAG_GNU_template_parameter_pack: {
     template_param_infos.packed_args.reset(
-      new ClangASTContext::TemplateParameterInfos);
+      new TypeSystemClang::TemplateParameterInfos);
     for (DWARFDIE child_die = die.GetFirstChild(); child_die.IsValid();
          child_die = child_die.GetSibling()) {
       if (!ParseTemplateDIE(child_die, *template_param_infos.packed_args))
         return false;
     }
     if (const char *name = die.GetName()) {
       template_param_infos.pack_name = name;
     }
bool DWARFASTParserClang::ParseTemplateDIE(
   default:
     break;
   }
   return false;
 }
 
 bool DWARFASTParserClang::ParseTemplateParameterInfos(
     const DWARFDIE &parent_die,
-    ClangASTContext::TemplateParameterInfos &template_param_infos) {
+    TypeSystemClang::TemplateParameterInfos &template_param_infos) {
 
   if (!parent_die)
     return false;
 
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
     const dw_tag_t tag = die.Tag();
 
bool DWARFASTParserClang::CompleteRecordType(const DWARFDIE &die,
   const dw_tag_t tag = die.Tag();
   SymbolFileDWARF *dwarf = die.GetDWARF();
 
   ClangASTImporter::LayoutInfo layout_info;
 
   {
     if (die.HasChildren()) {
       LanguageType class_language = eLanguageTypeUnknown;
-      if (ClangASTContext::IsObjCObjectOrInterfaceType(clang_type)) {
+      if (TypeSystemClang::IsObjCObjectOrInterfaceType(clang_type)) {
         class_language = eLanguageTypeObjC;
         // For objective C we don't start the definition when the class is
         // created.
-        ClangASTContext::StartTagDeclarationDefinition(clang_type);
+        TypeSystemClang::StartTagDeclarationDefinition(clang_type);
       }
 
       int tag_decl_kind = -1;
       AccessType default_accessibility = eAccessNone;
       if (tag == DW_TAG_structure_type) {
         tag_decl_kind = clang::TTK_Struct;
         default_accessibility = eAccessPublic;
       } else if (tag == DW_TAG_union_type) {
if (die.HasChildren()) {
 
               // We have no choice other than to pretend that the base class
               // is complete. If we don't do this, clang will crash when we
               // call setBases() inside of
               // "clang_type.TransferBaseClasses()" below. Since we
               // provide layout assistance, all ivars in this class and other
               // classes will be fine, this is the best we can do short of
               // crashing.
-              if (ClangASTContext::StartTagDeclarationDefinition(
+              if (TypeSystemClang::StartTagDeclarationDefinition(
                       base_class_type)) {
-                ClangASTContext::CompleteTagDeclarationDefinition(
+                TypeSystemClang::CompleteTagDeclarationDefinition(
                     base_class_type);
               }
             }
           }
         }
 
         m_ast.TransferBaseClasses(clang_type.GetOpaqueQualType(),
                                   std::move(bases));
       }
     }
   }
 
   m_ast.AddMethodOverridesForCXXRecordType(clang_type.GetOpaqueQualType());
-  ClangASTContext::BuildIndirectFields(clang_type);
-  ClangASTContext::CompleteTagDeclarationDefinition(clang_type);
+  TypeSystemClang::BuildIndirectFields(clang_type);
+  TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
 
   if (!layout_info.field_offsets.empty() || !layout_info.base_offsets.empty() ||
       !layout_info.vbase_offsets.empty()) {
     if (type)
       layout_info.bit_size = type->GetByteSize().getValueOr(0) * 8;
     if (layout_info.bit_size == 0)
       layout_info.bit_size =
           die.GetAttributeValueAsUnsigned(DW_AT_byte_size, 0) * 8;
 
     clang::CXXRecordDecl *record_decl =
         m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
     if (record_decl)
       GetClangASTImporter().SetRecordLayout(record_decl, layout_info);
   }
 
   return (bool)clang_type;
 }
 
 bool DWARFASTParserClang::CompleteEnumType(const DWARFDIE &die,
                                            lldb_private::Type *type,
                                            CompilerType &clang_type) {
-  if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) {
+  if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
     if (die.HasChildren()) {
       bool is_signed = false;
       clang_type.IsIntegerType(is_signed);
       ParseChildEnumerators(clang_type, is_signed,
                             type->GetByteSize().getValueOr(0), die);
     }
-    ClangASTContext::CompleteTagDeclarationDefinition(clang_type);
+    TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
   }
   return (bool)clang_type;
 }
 
 bool DWARFASTParserClang::CompleteTypeFromDWARF(const DWARFDIE &die,
                                                 lldb_private::Type *type,
                                                 CompilerType &clang_type) {
   SymbolFileDWARF *dwarf = die.GetDWARF();
if (num_attributes > 0) {
 
     // Handle static members
     if (is_external && member_byte_offset == UINT32_MAX) {
       Type *var_type = die.ResolveTypeUID(encoding_form.Reference());
 
       if (var_type) {
         if (accessibility == eAccessNone)
           accessibility = eAccessPublic;
-        ClangASTContext::AddVariableToRecordType(
+        TypeSystemClang::AddVariableToRecordType(
             class_clang_type, name, var_type->GetLayoutCompilerType(),
             accessibility);
       }
       return;
     }
 
     if (!is_artificial) {
       Type *member_type = die.ResolveTypeUID(encoding_form.Reference());
if (!is_artificial) {
                         this_field_info.bit_offset - last_field_end;
                     anon_field_info.bit_offset = last_field_end;
                   }
                 }
               }
 
               if (anon_field_info.IsValid()) {
                 clang::FieldDecl *unnamed_bitfield_decl =
-                    ClangASTContext::AddFieldToRecordType(
+                    TypeSystemClang::AddFieldToRecordType(
                         class_clang_type, llvm::StringRef(),
                         m_ast.GetBuiltinTypeForEncodingAndBitSize(eEncodingSint,
                                                                   word_width),
                         accessibility, anon_field_info.bit_size);
 
                 layout_info.field_offsets.insert(std::make_pair(
                     unnamed_bitfield_decl, anon_field_info.bit_offset));
               }
if (!is_artificial) {
                 }
 
                 member_clang_type =
                     m_ast.CreateArrayType(member_array_element_type, 0, false);
               }
             }
           }
 
-          if (ClangASTContext::IsCXXClassType(member_clang_type) &&
+          if (TypeSystemClang::IsCXXClassType(member_clang_type) &&
               !member_clang_type.GetCompleteType()) {
             if (die.GetCU()->GetProducer() == eProducerClang)
               module_sp->ReportError(
                   "DWARF DIE at 0x%8.8x (class %s) has a member variable "
                   "0x%8.8x (%s) whose type is a forward declaration, not a "
                   "complete definition.\nTry compiling the source file "
                   "with -fstandalone-debug",
                   parent_die.GetOffset(), parent_die.GetName(), die.GetOffset(),
                   name);
             else
               module_sp->ReportError(
                   "DWARF DIE at 0x%8.8x (class %s) has a member variable "
                   "0x%8.8x (%s) whose type is a forward declaration, not a "
                   "complete definition.\nPlease file a bug against the "
                   "compiler and include the preprocessed output for %s",
                   parent_die.GetOffset(), parent_die.GetName(), die.GetOffset(),
                   name, GetUnitName(parent_die).c_str());
             // We have no choice other than to pretend that the member
             // class is complete. If we don't do this, clang will crash
             // when trying to layout the class. Since we provide layout
             // assistance, all ivars in this class and other classes will
             // be fine, this is the best we can do short of crashing.
-            if (ClangASTContext::StartTagDeclarationDefinition(
+            if (TypeSystemClang::StartTagDeclarationDefinition(
                     member_clang_type)) {
-              ClangASTContext::CompleteTagDeclarationDefinition(
+              TypeSystemClang::CompleteTagDeclarationDefinition(
                   member_clang_type);
             } else {
               module_sp->ReportError(
                   "DWARF DIE at 0x%8.8x (class %s) has a member variable "
                   "0x%8.8x (%s) whose type claims to be a C++ class but we "
                   "were not able to start its definition.\nPlease file a "
                   "bug and attach the file at the start of this error "
                   "message",
                   parent_die.GetOffset(), parent_die.GetName(), die.GetOffset(),
                   name);
             }
           }
 
-          field_decl = ClangASTContext::AddFieldToRecordType(
+          field_decl = TypeSystemClang::AddFieldToRecordType(
               class_clang_type, name, member_clang_type, accessibility,
               bit_size);
 
           m_ast.SetMetadataAsUserID(field_decl, die.GetID());
 
           layout_info.field_offsets.insert(
               std::make_pair(field_decl, field_bit_offset));
         } else {
bool DWARFASTParserClang::ParseChildMembers(
     DelayedPropertyList &delayed_properties, AccessType &default_accessibility,
     bool &is_a_class, ClangASTImporter::LayoutInfo &layout_info) {
   if (!parent_die)
     return false;
 
   BitfieldInfo last_field_info;
 
   ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
-  ClangASTContext *ast =
-      llvm::dyn_cast_or_null<ClangASTContext>(class_clang_type.GetTypeSystem());
+  TypeSystemClang *ast =
+      llvm::dyn_cast_or_null<TypeSystemClang>(class_clang_type.GetTypeSystem());
   if (ast == nullptr)
     return false;
 
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
     dw_tag_t tag = die.Tag();
 
     switch (tag) {
clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(const DWARFDIE &die) {
   case DW_TAG_variable:
   case DW_TAG_constant:
   case DW_TAG_formal_parameter: {
     SymbolFileDWARF *dwarf = die.GetDWARF();
     Type *type = GetTypeForDIE(die);
     if (dwarf && type) {
       const char *name = die.GetName();
       clang::DeclContext *decl_context =
-          ClangASTContext::DeclContextGetAsDeclContext(
+          TypeSystemClang::DeclContextGetAsDeclContext(
               dwarf->GetDeclContextContainingUID(die.GetID()));
       decl = m_ast.CreateVariableDeclaration(
           decl_context, name,
           ClangUtil::GetQualType(type->GetForwardCompilerType()));
     }
     break;
   }
   case DW_TAG_imported_declaration: {
     SymbolFileDWARF *dwarf = die.GetDWARF();
     DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
     if (imported_uid) {
       CompilerDecl imported_decl = imported_uid.GetDecl();
       if (imported_decl) {
         clang::DeclContext *decl_context =
-            ClangASTContext::DeclContextGetAsDeclContext(
+            TypeSystemClang::DeclContextGetAsDeclContext(
                 dwarf->GetDeclContextContainingUID(die.GetID()));
         if (clang::NamedDecl *clang_imported_decl =
                 llvm::dyn_cast<clang::NamedDecl>(
                     (clang::Decl *)imported_decl.GetOpaqueDecl()))
           decl =
               m_ast.CreateUsingDeclaration(decl_context, clang_imported_decl);
       }
     }
     break;
   }
   case DW_TAG_imported_module: {
     SymbolFileDWARF *dwarf = die.GetDWARF();
     DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
 
     if (imported_uid) {
       CompilerDeclContext imported_decl_ctx = imported_uid.GetDeclContext();
       if (imported_decl_ctx) {
         clang::DeclContext *decl_context =
-            ClangASTContext::DeclContextGetAsDeclContext(
+            TypeSystemClang::DeclContextGetAsDeclContext(
                 dwarf->GetDeclContextContainingUID(die.GetID()));
         if (clang::NamespaceDecl *ns_decl =
-                ClangASTContext::DeclContextGetAsNamespaceDecl(
+                TypeSystemClang::DeclContextGetAsNamespaceDecl(
                     imported_decl_ctx))
           decl = m_ast.CreateUsingDirectiveDeclaration(decl_context, ns_decl);
       }
     }
     break;
   }
   default:
     break;

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 
 #include "lldb/Symbol/Block.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Symbol/ObjectFile.h"
bool SymbolFileDWARF::HasForwardDeclForClangType(
   CompilerType compiler_type_no_qualifiers =
       ClangUtil::RemoveFastQualifiers(compiler_type);
   if (GetForwardDeclClangTypeToDie().count(
           compiler_type_no_qualifiers.GetOpaqueQualType())) {
     return true;
   }
   TypeSystem *type_system = compiler_type.GetTypeSystem();
 
-  ClangASTContext *clang_type_system =
-      llvm::dyn_cast_or_null<ClangASTContext>(type_system);
+  TypeSystemClang *clang_type_system =
+      llvm::dyn_cast_or_null<TypeSystemClang>(type_system);
   if (!clang_type_system)
     return false;
   DWARFASTParserClang *ast_parser =
       static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
   return ast_parser->GetClangASTImporter().CanImport(compiler_type);
 }
 
 bool SymbolFileDWARF::CompleteType(CompilerType &compiler_type) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
-  ClangASTContext *clang_type_system =
-      llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem());
+  TypeSystemClang *clang_type_system =
+      llvm::dyn_cast_or_null<TypeSystemClang>(compiler_type.GetTypeSystem());
   if (clang_type_system) {
     DWARFASTParserClang *ast_parser =
         static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
     if (ast_parser &&
         ast_parser->GetClangASTImporter().CanImport(compiler_type))
       return ast_parser->GetClangASTImporter().CompleteType(compiler_type);
   }
 
void SymbolFileDWARF::Dump(lldb_private::Stream &s) {
   SymbolFile::Dump(s);
   m_index->Dump(s);
 }
 
 void SymbolFileDWARF::DumpClangAST(Stream &s) {
   auto ts_or_err = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus);
   if (!ts_or_err)
     return;
-  ClangASTContext *clang =
-      llvm::dyn_cast_or_null<ClangASTContext>(&ts_or_err.get());
+  TypeSystemClang *clang =
+      llvm::dyn_cast_or_null<TypeSystemClang>(&ts_or_err.get());
   if (!clang)
     return;
   clang->Dump(s);
 }
 
 SymbolFileDWARFDebugMap *SymbolFileDWARF::GetDebugMapSymfile() {
   if (m_debug_map_symfile == nullptr && !m_debug_map_module_wp.expired()) {
     lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());

lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h

DeclStatus(lldb::user_id_t uid, bool resolved)
       : uid(uid), resolved(resolved) {}
   lldb::user_id_t uid = 0;
   bool resolved = false;
 };
 
 class PdbAstBuilder {
 public:
   // Constructors and Destructors
-  PdbAstBuilder(ObjectFile &obj, PdbIndex &index, ClangASTContext &clang);
+  PdbAstBuilder(ObjectFile &obj, PdbIndex &index, TypeSystemClang &clang);
 
   lldb_private::CompilerDeclContext GetTranslationUnitDecl();
 
   llvm::Optional<lldb_private::CompilerDecl>
   GetOrCreateDeclForUid(PdbSymUid uid);
   clang::DeclContext *GetOrCreateDeclContextForUid(PdbSymUid uid);
   clang::DeclContext *GetParentDeclContext(PdbSymUid uid);
 
public:
   bool CompleteType(clang::QualType qt);
 
   CompilerDecl ToCompilerDecl(clang::Decl &decl);
   CompilerType ToCompilerType(clang::QualType qt);
   CompilerDeclContext ToCompilerDeclContext(clang::DeclContext &context);
   clang::Decl *FromCompilerDecl(CompilerDecl decl);
   clang::DeclContext *FromCompilerDeclContext(CompilerDeclContext context);
 
-  ClangASTContext &clang() { return m_clang; }
+  TypeSystemClang &clang() { return m_clang; }
   ClangASTImporter &importer() { return m_importer; }
 
   void Dump(Stream &stream);
 
 private:
   clang::Decl *TryGetDecl(PdbSymUid uid) const;
 
   using TypeIndex = llvm::codeview::TypeIndex;
private:
   void BuildParentMap();
   std::pair<clang::DeclContext *, std::string>
   CreateDeclInfoForType(const llvm::codeview::TagRecord &record, TypeIndex ti);
   std::pair<clang::DeclContext *, std::string>
   CreateDeclInfoForUndecoratedName(llvm::StringRef uname);
   clang::QualType CreateSimpleType(TypeIndex ti);
 
   PdbIndex &m_index;
-  ClangASTContext &m_clang;
+  TypeSystemClang &m_clang;
 
   ClangASTImporter m_importer;
 
   llvm::DenseMap<TypeIndex, TypeIndex> m_parent_types;
   llvm::DenseMap<clang::Decl *, DeclStatus> m_decl_to_status;
   llvm::DenseMap<lldb::user_id_t, clang::Decl *> m_uid_to_decl;
   llvm::DenseMap<lldb::user_id_t, clang::QualType> m_uid_to_type;
 };
 
 } // namespace npdb
 } // namespace lldb_private
 
 #endif // lldb_Plugins_SymbolFile_PDB_SymbolFilePDB_h_

lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
 #include "llvm/DebugInfo/PDB/Native/PublicsStream.h"
 #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/Demangle/MicrosoftDemangle.h"
 
 #include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangASTMetadata.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/LLDBAssert.h"
 
 #include "PdbUtil.h"
 #include "UdtRecordCompleter.h"
 
GetNestedTagDefinition(const NestedTypeRecord &Record,
 
   return std::move(child);
 }
 
 static bool IsAnonymousNamespaceName(llvm::StringRef name) {
   return name == "`anonymous namespace'" || name == "`anonymous-namespace'";
 }
 
-PdbAstBuilder::PdbAstBuilder(ObjectFile &obj, PdbIndex &index, ClangASTContext &clang)
+PdbAstBuilder::PdbAstBuilder(ObjectFile &obj, PdbIndex &index, TypeSystemClang &clang)
     : m_index(index), m_clang(clang) {
   BuildParentMap();
 }
 
 lldb_private::CompilerDeclContext PdbAstBuilder::GetTranslationUnitDecl() {
   return ToCompilerDeclContext(*m_clang.GetTranslationUnitDecl());
 }
 
bool PdbAstBuilder::CompleteTagDecl(clang::TagDecl &tag) {
   if (status.resolved)
     return true;
 
   PdbTypeSymId type_id = PdbSymUid(status.uid).asTypeSym();
 
   lldbassert(IsTagRecord(type_id, m_index.tpi()));
 
   clang::QualType tag_qt = m_clang.getASTContext().getTypeDeclType(&tag);
-  ClangASTContext::SetHasExternalStorage(tag_qt.getAsOpaquePtr(), false);
+  TypeSystemClang::SetHasExternalStorage(tag_qt.getAsOpaquePtr(), false);
 
   TypeIndex tag_ti = type_id.index;
   CVType cvt = m_index.tpi().getType(tag_ti);
   if (cvt.kind() == LF_MODIFIER)
     tag_ti = LookThroughModifierRecord(cvt);
 
   PdbTypeSymId best_ti = GetBestPossibleDecl(tag_ti, m_index.tpi());
   cvt = m_index.tpi().getType(best_ti.index);
clang::QualType PdbAstBuilder::CreateRecordType(PdbTypeSymId id,
   metadata.SetUserID(toOpaqueUid(id));
   metadata.SetIsDynamicCXXType(false);
 
   CompilerType ct = m_clang.CreateRecordType(
       context, access, uname, ttk, lldb::eLanguageTypeC_plus_plus, &metadata);
 
   lldbassert(ct.IsValid());
 
-  ClangASTContext::StartTagDeclarationDefinition(ct);
+  TypeSystemClang::StartTagDeclarationDefinition(ct);
 
   // Even if it's possible, don't complete it at this point. Just mark it
   // forward resolved, and if/when LLDB needs the full definition, it can
   // ask us.
   clang::QualType result =
       clang::QualType::getFromOpaquePtr(ct.GetOpaqueQualType());
 
-  ClangASTContext::SetHasExternalStorage(result.getAsOpaquePtr(), true);
+  TypeSystemClang::SetHasExternalStorage(result.getAsOpaquePtr(), true);
   return result;
 }
 
 clang::Decl *PdbAstBuilder::TryGetDecl(PdbSymUid uid) const {
   auto iter = m_uid_to_decl.find(toOpaqueUid(uid));
   if (iter != m_uid_to_decl.end())
     return iter->second;
   return nullptr;
clang::QualType PdbAstBuilder::CreateEnumType(PdbTypeSymId id,
   std::tie(decl_context, uname) = CreateDeclInfoForType(er, id.index);
   clang::QualType underlying_type = GetOrCreateType(er.UnderlyingType);
 
   Declaration declaration;
   CompilerType enum_ct = m_clang.CreateEnumerationType(
       uname.c_str(), decl_context, declaration, ToCompilerType(underlying_type),
       er.isScoped());
 
-  ClangASTContext::StartTagDeclarationDefinition(enum_ct);
-  ClangASTContext::SetHasExternalStorage(enum_ct.GetOpaqueQualType(), true);
+  TypeSystemClang::StartTagDeclarationDefinition(enum_ct);
+  TypeSystemClang::SetHasExternalStorage(enum_ct.GetOpaqueQualType(), true);
 
   return clang::QualType::getFromOpaquePtr(enum_ct.GetOpaqueQualType());
 }
 
 clang::QualType PdbAstBuilder::CreateArrayType(const ArrayRecord &ar) {
   clang::QualType element_type = GetOrCreateType(ar.ElementType);
 
   uint64_t element_count =

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Type.h"
 
 #include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamBuffer.h"
 #include "lldb/Core/StreamFile.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
void SymbolFileNativePDB::InitializeObject() {
 
   auto ts_or_err = m_objfile_sp->GetModule()->GetTypeSystemForLanguage(
       lldb::eLanguageTypeC_plus_plus);
   if (auto err = ts_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Failed to initialize");
   } else {
     ts_or_err->SetSymbolFile(this);
-    auto *clang = llvm::cast_or_null<ClangASTContext>(&ts_or_err.get());
+    auto *clang = llvm::cast_or_null<TypeSystemClang>(&ts_or_err.get());
     lldbassert(clang);
     m_ast = std::make_unique<PdbAstBuilder>(*m_objfile_sp, *m_index, *clang);
   }
 }
 
 uint32_t SymbolFileNativePDB::CalculateNumCompileUnits() {
   const DbiModuleList &modules = m_index->dbi().modules();
   uint32_t count = modules.getModuleCount();

lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.cpp

 #include "UdtRecordCompleter.h"
 
 #include "PdbAstBuilder.h"
 #include "PdbIndex.h"
 #include "PdbSymUid.h"
 #include "PdbUtil.h"
 
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 
 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
clang::QualType member_type =
       m_ast_builder.GetOrCreateType(PdbTypeSymId(static_data_member.Type));
 
   m_ast_builder.CompleteType(member_type);
 
   CompilerType member_ct = m_ast_builder.ToCompilerType(member_type);
 
   lldb::AccessType access =
       TranslateMemberAccess(static_data_member.getAccess());
-  ClangASTContext::AddVariableToRecordType(
+  TypeSystemClang::AddVariableToRecordType(
       m_derived_ct, static_data_member.Name, member_ct, access);
 
   // FIXME: Add a PdbSymUid namespace for field list members and update
   // the m_uid_to_decl map with this decl.
   return Error::success();
 }
 
 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
if (!ti.isSimple()) {
     }
   }
 
   clang::QualType member_qt = m_ast_builder.GetOrCreateType(PdbTypeSymId(ti));
   m_ast_builder.CompleteType(member_qt);
 
   lldb::AccessType access = TranslateMemberAccess(data_member.getAccess());
 
-  clang::FieldDecl *decl = ClangASTContext::AddFieldToRecordType(
+  clang::FieldDecl *decl = TypeSystemClang::AddFieldToRecordType(
       m_derived_ct, data_member.Name, m_ast_builder.ToCompilerType(member_qt),
       access, bitfield_width);
   // FIXME: Add a PdbSymUid namespace for field list members and update
   // the m_uid_to_decl map with this decl.
 
   m_layout.field_offsets.insert(std::make_pair(decl, offset));
 
   return Error::success();
std::stable_sort(m_bases.begin(), m_bases.end(),
                      return lhs.first < rhs.first;
                    });
 
   std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases;
   bases.reserve(m_bases.size());
   for (auto &ib : m_bases)
     bases.push_back(std::move(ib.second));
 
-  ClangASTContext &clang = m_ast_builder.clang();
+  TypeSystemClang &clang = m_ast_builder.clang();
   clang.TransferBaseClasses(m_derived_ct.GetOpaqueQualType(), std::move(bases));
 
   clang.AddMethodOverridesForCXXRecordType(m_derived_ct.GetOpaqueQualType());
-  ClangASTContext::BuildIndirectFields(m_derived_ct);
-  ClangASTContext::CompleteTagDeclarationDefinition(m_derived_ct);
+  TypeSystemClang::BuildIndirectFields(m_derived_ct);
+  TypeSystemClang::CompleteTagDeclarationDefinition(m_derived_ct);
 
   if (auto *record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(&m_tag_decl)) {
     m_ast_builder.importer().SetRecordLayout(record_decl, m_layout);
   }
 }

lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.h

 namespace clang {
 class CharUnits;
 class CXXRecordDecl;
 class FieldDecl;
 class RecordDecl;
 } // namespace clang
 
 namespace lldb_private {
-class ClangASTContext;
+class TypeSystemClang;
 class CompilerType;
 } // namespace lldb_private
 
 namespace llvm {
 namespace pdb {
 template <typename ChildType> class ConcreteSymbolEnumerator;
 
 class PDBSymbol;
 class PDBSymbolData;
 class PDBSymbolFunc;
 class PDBSymbolTypeBaseClass;
 class PDBSymbolTypeBuiltin;
 class PDBSymbolTypeUDT;
 } // namespace pdb
 } // namespace llvm
 
 class PDBASTParser {
 public:
-  PDBASTParser(lldb_private::ClangASTContext &ast);
+  PDBASTParser(lldb_private::TypeSystemClang &ast);
   ~PDBASTParser();
 
   lldb::TypeSP CreateLLDBTypeFromPDBType(const llvm::pdb::PDBSymbol &type);
   bool CompleteTypeFromPDB(lldb_private::CompilerType &compiler_type);
 
   clang::Decl *GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol);
 
   clang::DeclContext *
private:
   void AddRecordMethods(lldb_private::SymbolFile &symbol_file,
                         lldb_private::CompilerType &record_type,
                         PDBFuncSymbolEnumerator &methods_enum);
   clang::CXXMethodDecl *
   AddRecordMethod(lldb_private::SymbolFile &symbol_file,
                   lldb_private::CompilerType &record_type,
                   const llvm::pdb::PDBSymbolFunc &method) const;
 
-  lldb_private::ClangASTContext &m_ast;
+  lldb_private::TypeSystemClang &m_ast;
   lldb_private::ClangASTImporter m_ast_importer;
 
   CXXRecordDeclToUidMap m_forward_decl_to_uid;
   UidToDeclMap m_uid_to_decl;
   ParentToNamespacesMap m_parent_to_namespaces;
   NamespacesSet m_namespaces;
   DeclContextToUidMap m_decl_context_to_uid;
 };
 
 #endif // LLDB_PLUGINS_SYMBOLFILE_PDB_PDBASTPARSER_H

lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

 
 #include "SymbolFilePDB.h"
 
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 
 #include "lldb/Core/Module.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangASTMetadata.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/Declaration.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/TypeSystem.h"
 
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
static lldb::Encoding TranslateEnumEncoding(PDB_VariantType type) {
   default:
     break;
   }
 
   return lldb::eEncodingSint;
 }
 
 static CompilerType
-GetBuiltinTypeForPDBEncodingAndBitSize(ClangASTContext &clang_ast,
+GetBuiltinTypeForPDBEncodingAndBitSize(TypeSystemClang &clang_ast,
                                        const PDBSymbolTypeBuiltin &pdb_type,
                                        Encoding encoding, uint32_t width) {
   clang::ASTContext &ast = clang_ast.getASTContext();
 
   switch (pdb_type.getBuiltinType()) {
   default:
     break;
   case PDB_BuiltinType::None:
static clang::CallingConv TranslateCallingConvention(PDB_CallingConv pdb_cc) {
   case llvm::codeview::CallingConvention::NearPascal:
     return clang::CC_X86Pascal;
   default:
     assert(false && "Unknown calling convention");
     return clang::CC_C;
   }
 }
 
-PDBASTParser::PDBASTParser(lldb_private::ClangASTContext &ast) : m_ast(ast) {}
+PDBASTParser::PDBASTParser(lldb_private::TypeSystemClang &ast) : m_ast(ast) {}
 
 PDBASTParser::~PDBASTParser() {}
 
 // DebugInfoASTParser interface
 
 lldb::TypeSP PDBASTParser::CreateLLDBTypeFromPDBType(const PDBSymbol &type) {
   Declaration decl;
   switch (type.getSymTag()) {
if (!clang_type.IsValid()) {
           m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
       assert(record_decl);
       m_uid_to_decl[type.getSymIndexId()] = record_decl;
 
       auto inheritance_attr = clang::MSInheritanceAttr::CreateImplicit(
           m_ast.getASTContext(), GetMSInheritance(*udt));
       record_decl->addAttr(inheritance_attr);
 
-      ClangASTContext::StartTagDeclarationDefinition(clang_type);
+      TypeSystemClang::StartTagDeclarationDefinition(clang_type);
 
       auto children = udt->findAllChildren();
       if (!children || children->getChildCount() == 0) {
         // PDB does not have symbol of forwarder. We assume we get an udt w/o
         // any fields. Just complete it at this point.
-        ClangASTContext::CompleteTagDeclarationDefinition(clang_type);
+        TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
 
-        ClangASTContext::SetHasExternalStorage(clang_type.GetOpaqueQualType(),
+        TypeSystemClang::SetHasExternalStorage(clang_type.GetOpaqueQualType(),
                                                false);
 
         type_resolve_state = Type::ResolveState::Full;
       } else {
         // Add the type to the forward declarations. It will help us to avoid
         // an endless recursion in CompleteTypeFromUdt function.
         m_forward_decl_to_uid[record_decl] = type.getSymIndexId();
 
-        ClangASTContext::SetHasExternalStorage(clang_type.GetOpaqueQualType(),
+        TypeSystemClang::SetHasExternalStorage(clang_type.GetOpaqueQualType(),
                                                true);
 
         type_resolve_state = Type::ResolveState::Forward;
       }
     } else
       type_resolve_state = Type::ResolveState::Forward;
 
     if (udt->isConstType())
if (!ast_enum.IsValid()) {
 
       // FIXME: PDB does not have information about scoped enumeration (Enum
       // Class). Set it false for now.
       bool isScoped = false;
 
       ast_enum = m_ast.CreateEnumerationType(name.c_str(), decl_context, decl,
                                              builtin_type, isScoped);
 
-      auto enum_decl = ClangASTContext::GetAsEnumDecl(ast_enum);
+      auto enum_decl = TypeSystemClang::GetAsEnumDecl(ast_enum);
       assert(enum_decl);
       m_uid_to_decl[type.getSymIndexId()] = enum_decl;
 
       auto enum_values = enum_type->findAllChildren<PDBSymbolData>();
       if (enum_values) {
         while (auto enum_value = enum_values->getNext()) {
           if (enum_value->getDataKind() != PDB_DataKind::Constant)
             continue;
           AddEnumValue(ast_enum, *enum_value);
         }
       }
 
-      if (ClangASTContext::StartTagDeclarationDefinition(ast_enum))
-        ClangASTContext::CompleteTagDeclarationDefinition(ast_enum);
+      if (TypeSystemClang::StartTagDeclarationDefinition(ast_enum))
+        TypeSystemClang::CompleteTagDeclarationDefinition(ast_enum);
     }
 
     if (enum_type->isConstType())
       ast_enum = ast_enum.AddConstModifier();
 
     if (enum_type->isVolatileType())
       ast_enum = ast_enum.AddVolatileModifier();
 
case PDB_SymType::Typedef: {
     if (!ast_typedef.IsValid()) {
       CompilerType target_ast_type = target_type->GetFullCompilerType();
 
       ast_typedef = m_ast.CreateTypedefType(
           target_ast_type, name.c_str(), m_ast.CreateDeclContext(decl_ctx));
       if (!ast_typedef)
         return nullptr;
 
-      auto typedef_decl = ClangASTContext::GetAsTypedefDecl(ast_typedef);
+      auto typedef_decl = TypeSystemClang::GetAsTypedefDecl(ast_typedef);
       assert(typedef_decl);
       m_uid_to_decl[type.getSymIndexId()] = typedef_decl;
     }
 
     if (type_def->isConstType())
       ast_typedef = ast_typedef.AddConstModifier();
 
     if (type_def->isVolatileType())
case PDB_SymType::ArrayType: {
     // will parsed in the order N=0, N=1,..., N=rank sequentially.
     lldb_private::Type *element_type =
         m_ast.GetSymbolFile()->ResolveTypeUID(element_uid);
     if (!element_type)
       return nullptr;
 
     CompilerType element_ast_type = element_type->GetForwardCompilerType();
     // If element type is UDT, it needs to be complete.
-    if (ClangASTContext::IsCXXClassType(element_ast_type) &&
+    if (TypeSystemClang::IsCXXClassType(element_ast_type) &&
         !element_ast_type.GetCompleteType()) {
-      if (ClangASTContext::StartTagDeclarationDefinition(element_ast_type)) {
-        ClangASTContext::CompleteTagDeclarationDefinition(element_ast_type);
+      if (TypeSystemClang::StartTagDeclarationDefinition(element_ast_type)) {
+        TypeSystemClang::CompleteTagDeclarationDefinition(element_ast_type);
       } else {
         // We are not able to start defintion.
         return nullptr;
       }
     }
     CompilerType array_ast_type = m_ast.CreateArrayType(
         element_ast_type, num_elements, /*is_gnu_vector*/ false);
     TypeSP type_sp = std::make_shared<lldb_private::Type>(
case PDB_SymType::PointerType: {
     if (pointer_type->isPointerToDataMember() ||
         pointer_type->isPointerToMemberFunction()) {
       auto class_parent_uid = pointer_type->getRawSymbol().getClassParentId();
       auto class_parent_type =
           m_ast.GetSymbolFile()->ResolveTypeUID(class_parent_uid);
       assert(class_parent_type);
 
       CompilerType pointer_ast_type;
-      pointer_ast_type = ClangASTContext::CreateMemberPointerType(
+      pointer_ast_type = TypeSystemClang::CreateMemberPointerType(
           class_parent_type->GetLayoutCompilerType(),
           pointee_type->GetForwardCompilerType());
       assert(pointer_ast_type);
 
       return std::make_shared<lldb_private::Type>(
           pointer_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(),
           pointer_type->getLength(), nullptr, LLDB_INVALID_UID,
           lldb_private::Type::eEncodingIsUID, decl, pointer_ast_type,
bool PDBASTParser::CompleteTypeFromPDB(
 
   std::unique_ptr<PDBSymbol> symbol =
       symbol_file->GetPDBSession().getSymbolById(uid_it->getSecond());
   if (!symbol)
     return false;
 
   m_forward_decl_to_uid.erase(uid_it);
 
-  ClangASTContext::SetHasExternalStorage(compiler_type.GetOpaqueQualType(),
+  TypeSystemClang::SetHasExternalStorage(compiler_type.GetOpaqueQualType(),
                                          false);
 
   switch (symbol->getSymTag()) {
   case PDB_SymType::UDT: {
     auto udt = llvm::dyn_cast<PDBSymbolTypeUDT>(symbol.get());
     if (!udt)
       return false;
 
bool PDBASTParser::CompleteTypeFromUDT(
   if (members_enum)
     AddRecordMembers(symbol_file, compiler_type, *members_enum, layout_info);
 
   auto methods_enum = udt.findAllChildren<PDBSymbolFunc>();
   if (methods_enum)
     AddRecordMethods(symbol_file, compiler_type, *methods_enum);
 
   m_ast.AddMethodOverridesForCXXRecordType(compiler_type.GetOpaqueQualType());
-  ClangASTContext::BuildIndirectFields(compiler_type);
-  ClangASTContext::CompleteTagDeclarationDefinition(compiler_type);
+  TypeSystemClang::BuildIndirectFields(compiler_type);
+  TypeSystemClang::CompleteTagDeclarationDefinition(compiler_type);
 
   clang::CXXRecordDecl *record_decl =
       m_ast.GetAsCXXRecordDecl(compiler_type.GetOpaqueQualType());
   if (!record_decl)
     return static_cast<bool>(compiler_type);
 
   GetClangASTImporter().SetRecordLayout(record_decl, layout_info);
 
while (auto member = members_enum.getNext()) {
 
     auto member_comp_type = member_type->GetLayoutCompilerType();
     if (!member_comp_type.GetCompleteType()) {
       symbol_file.GetObjectFile()->GetModule()->ReportError(
           ":: Class '%s' has a member '%s' of type '%s' "
           "which does not have a complete definition.",
           record_type.GetTypeName().GetCString(), member_name.c_str(),
           member_comp_type.GetTypeName().GetCString());
-      if (ClangASTContext::StartTagDeclarationDefinition(member_comp_type))
-        ClangASTContext::CompleteTagDeclarationDefinition(member_comp_type);
+      if (TypeSystemClang::StartTagDeclarationDefinition(member_comp_type))
+        TypeSystemClang::CompleteTagDeclarationDefinition(member_comp_type);
     }
 
     auto access = TranslateMemberAccess(member->getAccess());
 
     switch (member->getDataKind()) {
     case PDB_DataKind::Member: {
       auto location_type = member->getLocationType();
 
       auto bit_size = member->getLength();
       if (location_type == PDB_LocType::ThisRel)
         bit_size *= 8;
 
-      auto decl = ClangASTContext::AddFieldToRecordType(
+      auto decl = TypeSystemClang::AddFieldToRecordType(
           record_type, member_name.c_str(), member_comp_type, access, bit_size);
       if (!decl)
         continue;
 
       m_uid_to_decl[member->getSymIndexId()] = decl;
 
       auto offset = member->getOffset() * 8;
       if (location_type == PDB_LocType::BitField)
         offset += member->getBitPosition();
 
       layout_info.field_offsets.insert(std::make_pair(decl, offset));
 
       break;
     }
     case PDB_DataKind::StaticMember: {
-      auto decl = ClangASTContext::AddVariableToRecordType(
+      auto decl = TypeSystemClang::AddVariableToRecordType(
           record_type, member_name.c_str(), member_comp_type, access);
       if (!decl)
         continue;
 
       m_uid_to_decl[member->getSymIndexId()] = decl;
 
       break;
     }
while (auto base = bases_enum.getNext()) {
 
     auto base_comp_type = base_type->GetFullCompilerType();
     if (!base_comp_type.GetCompleteType()) {
       symbol_file.GetObjectFile()->GetModule()->ReportError(
           ":: Class '%s' has a base class '%s' "
           "which does not have a complete definition.",
           record_type.GetTypeName().GetCString(),
           base_comp_type.GetTypeName().GetCString());
-      if (ClangASTContext::StartTagDeclarationDefinition(base_comp_type))
-        ClangASTContext::CompleteTagDeclarationDefinition(base_comp_type);
+      if (TypeSystemClang::StartTagDeclarationDefinition(base_comp_type))
+        TypeSystemClang::CompleteTagDeclarationDefinition(base_comp_type);
     }
 
     auto access = TranslateMemberAccess(base->getAccess());
 
     auto is_virtual = base->isVirtualBaseClass();
 
     std::unique_ptr<clang::CXXBaseSpecifier> base_spec =
         m_ast.CreateBaseClassSpecifier(base_comp_type.GetOpaqueQualType(),
if (!method_type)
     return nullptr;
 
   CompilerType method_comp_type = method_type->GetFullCompilerType();
   if (!method_comp_type.GetCompleteType()) {
     symbol_file.GetObjectFile()->GetModule()->ReportError(
         ":: Class '%s' has a method '%s' whose type cannot be completed.",
         record_type.GetTypeName().GetCString(),
         method_comp_type.GetTypeName().GetCString());
-    if (ClangASTContext::StartTagDeclarationDefinition(method_comp_type))
-      ClangASTContext::CompleteTagDeclarationDefinition(method_comp_type);
+    if (TypeSystemClang::StartTagDeclarationDefinition(method_comp_type))
+      TypeSystemClang::CompleteTagDeclarationDefinition(method_comp_type);
   }
 
   AccessType access = TranslateMemberAccess(method.getAccess());
   if (access == eAccessNone)
     access = eAccessPublic;
 
   // TODO: get mangled name for the method.
   return m_ast.AddMethodToCXXRecordType(
       record_type.GetOpaqueQualType(), name.c_str(),
       /*mangled_name*/ nullptr, method_comp_type, access, method.isVirtual(),
       method.isStatic(), method.hasInlineAttribute(),
       /*is_explicit*/ false, // FIXME: Need this field in CodeView.
       /*is_attr_used*/ false,
       /*is_artificial*/ method.isCompilerGenerated());
 }

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

 
 #include "PDBASTParser.h"
 #include "PDBLocationToDWARFExpression.h"
 
 #include "clang/Lex/Lexer.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/Variable.h"
SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(const PDBSymbolFunc &pdb_func,
   LanguageType lang = ParseLanguage(comp_unit);
   auto type_system_or_err = GetTypeSystemForLanguage(lang);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to parse PDBFunc");
     return nullptr;
   }
 
-  ClangASTContext *clang_type_system =
-    llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+  TypeSystemClang *clang_type_system =
+    llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_type_system)
     return nullptr;
   clang_type_system->GetPDBParser()->GetDeclForSymbol(pdb_func);
 
   return func_sp.get();
 }
 
 size_t SymbolFilePDB::ParseFunctions(CompileUnit &comp_unit) {
lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
   auto type_system_or_err =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to ResolveTypeUID");
     return nullptr;
   }
 
-  ClangASTContext *clang_type_system =
-      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+  TypeSystemClang *clang_type_system =
+      llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_type_system)
     return nullptr;
   PDBASTParser *pdb = clang_type_system->GetPDBParser();
   if (!pdb)
     return nullptr;
 
   auto pdb_type = m_session_up->getSymbolById(type_uid);
   if (pdb_type == nullptr)
bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {
   auto type_system_or_err =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to get dynamic array info for UID");
     return false;
   }
 
-  ClangASTContext *clang_ast_ctx =
-      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+  TypeSystemClang *clang_ast_ctx =
+      llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
 
   if (!clang_ast_ctx)
     return false;
 
   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
   if (!pdb)
     return false;
 
   return pdb->CompleteTypeFromPDB(compiler_type);
 }
 
 lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) {
   auto type_system_or_err =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to get decl for UID");
     return CompilerDecl();
   }
 
-  ClangASTContext *clang_ast_ctx =
-      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+  TypeSystemClang *clang_ast_ctx =
+      llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_ast_ctx)
     return CompilerDecl();
 
   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
   if (!pdb)
     return CompilerDecl();
 
   auto symbol = m_session_up->getSymbolById(uid);
SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) {
   auto type_system_or_err =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to get DeclContext for UID");
     return CompilerDeclContext();
   }
 
-  ClangASTContext *clang_ast_ctx =
-      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+  TypeSystemClang *clang_ast_ctx =
+      llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_ast_ctx)
     return CompilerDeclContext();
 
   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
   if (!pdb)
     return CompilerDeclContext();
 
   auto symbol = m_session_up->getSymbolById(uid);
SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
   auto type_system_or_err =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to get DeclContext containing UID");
     return CompilerDeclContext();
   }
 
-  ClangASTContext *clang_ast_ctx =
-      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+  TypeSystemClang *clang_ast_ctx =
+      llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_ast_ctx)
     return CompilerDeclContext();
 
   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
   if (!pdb)
     return CompilerDeclContext();
 
   auto symbol = m_session_up->getSymbolById(uid);
void SymbolFilePDB::ParseDeclsForContext(
   auto type_system_or_err =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to parse decls for context");
     return;
   }
 
-  ClangASTContext *clang_ast_ctx =
-      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+  TypeSystemClang *clang_ast_ctx =
+      llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_ast_ctx)
     return;
 
   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
   if (!pdb)
     return;
 
   pdb->ParseDeclsForDeclContext(
auto type_system_or_err =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to dump ClangAST");
     return;
   }
 
   auto *clang_type_system =
-      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+      llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_type_system)
     return;
   clang_type_system->Dump(s);
 }
 
 void SymbolFilePDB::FindTypesByRegex(
     const lldb_private::RegularExpression &regex, uint32_t max_matches,
     lldb_private::TypeMap &types) {
auto type_system_or_err =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to get PDB AST parser");
     return nullptr;
   }
 
   auto *clang_type_system =
-      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+      llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_type_system)
     return nullptr;
 
   return clang_type_system->GetPDBParser();
 }
 
 
 lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace(
     lldb_private::ConstString name,
     const lldb_private::CompilerDeclContext *parent_decl_ctx) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   auto type_system_or_err =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to find namespace {}",
                    name.AsCString());
     return CompilerDeclContext();
   }
 
   auto *clang_type_system =
-      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+      llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_type_system)
     return CompilerDeclContext();
 
   PDBASTParser *pdb = clang_type_system->GetPDBParser();
   if (!pdb)
     return CompilerDeclContext();
 
   clang::DeclContext *decl_context = nullptr;

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp

 #include "AppleGetItemInfoHandler.h"
 
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"

 AppleGetItemInfoHandler::GetItemInfoReturnInfo
 AppleGetItemInfoHandler::GetItemInfo(Thread &thread, uint64_t item,
                                      addr_t page_to_free,
                                      uint64_t page_to_free_size,
                                      Status &error) {
   lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
   ProcessSP process_sp(thread.CalculateProcess());
   TargetSP target_sp(thread.CalculateTarget());
-  ClangASTContext *clang_ast_context = ClangASTContext::GetScratch(*target_sp);
+  TypeSystemClang *clang_ast_context = TypeSystemClang::GetScratch(*target_sp);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
 
   GetItemInfoReturnInfo return_value;
   return_value.item_buffer_ptr = LLDB_INVALID_ADDRESS;
   return_value.item_buffer_size = 0;
 
   error.Clear();
 

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp

 #include "AppleGetPendingItemsHandler.h"
 
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
if (!m_get_pending_items_impl_code) {
         }
       } else {
         LLDB_LOGF(log, "No pending-items introspection code found.");
         return LLDB_INVALID_ADDRESS;
       }
 
       // Next make the runner function for our implementation utility function.
       Status error;
-      ClangASTContext *clang_ast_context =
-          ClangASTContext::GetScratch(thread.GetProcess()->GetTarget());
+      TypeSystemClang *clang_ast_context =
+          TypeSystemClang::GetScratch(thread.GetProcess()->GetTarget());
       CompilerType get_pending_items_return_type =
           clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
       get_pending_items_caller =
           m_get_pending_items_impl_code->MakeFunctionCaller(
               get_pending_items_return_type, get_pending_items_arglist,
               thread_sp, error);
       if (error.Fail() || get_pending_items_caller == nullptr) {
         LLDB_LOGF(log,

 AppleGetPendingItemsHandler::GetPendingItemsReturnInfo
 AppleGetPendingItemsHandler::GetPendingItems(Thread &thread, addr_t queue,
                                              addr_t page_to_free,
                                              uint64_t page_to_free_size,
                                              Status &error) {
   lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
   ProcessSP process_sp(thread.CalculateProcess());
   TargetSP target_sp(thread.CalculateTarget());
-  ClangASTContext *clang_ast_context = ClangASTContext::GetScratch(*target_sp);
+  TypeSystemClang *clang_ast_context = TypeSystemClang::GetScratch(*target_sp);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
 
   GetPendingItemsReturnInfo return_value;
   return_value.items_buffer_ptr = LLDB_INVALID_ADDRESS;
   return_value.items_buffer_size = 0;
   return_value.count = 0;
 
   error.Clear();

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp

 //===-- AppleGetQueuesHandler.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 "AppleGetQueuesHandler.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
if (!m_get_queues_impl_code_up) {
           LLDB_LOGF(log, "No queues introspection code found.");
           diagnostics.Dump(log);
         }
         return LLDB_INVALID_ADDRESS;
       }
     }
 
     // Next make the runner function for our implementation utility function.
-    ClangASTContext *clang_ast_context =
-        ClangASTContext::GetScratch(thread.GetProcess()->GetTarget());
+    TypeSystemClang *clang_ast_context =
+        TypeSystemClang::GetScratch(thread.GetProcess()->GetTarget());
     CompilerType get_queues_return_type =
         clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
     Status error;
     get_queues_caller = m_get_queues_impl_code_up->MakeFunctionCaller(
         get_queues_return_type, get_queues_arglist, thread_sp, error);
     if (error.Fail() || get_queues_caller == nullptr) {
       LLDB_LOGF(log,
                 "Could not get function caller for get-queues function: %s.",

 
 AppleGetQueuesHandler::GetQueuesReturnInfo
 AppleGetQueuesHandler::GetCurrentQueues(Thread &thread, addr_t page_to_free,
                                         uint64_t page_to_free_size,
                                         Status &error) {
   lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
   ProcessSP process_sp(thread.CalculateProcess());
   TargetSP target_sp(thread.CalculateTarget());
-  ClangASTContext *clang_ast_context = ClangASTContext::GetScratch(*target_sp);
+  TypeSystemClang *clang_ast_context = TypeSystemClang::GetScratch(*target_sp);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
 
   GetQueuesReturnInfo return_value;
   return_value.queues_buffer_ptr = LLDB_INVALID_ADDRESS;
   return_value.queues_buffer_size = 0;
   return_value.count = 0;
 
   error.Clear();

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp

 
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
if (!m_get_thread_item_info_impl_code) {
         }
       } else {
         LLDB_LOGF(log, "No get-thread-item-info introspection code found.");
         return LLDB_INVALID_ADDRESS;
       }
 
       // Also make the FunctionCaller for this UtilityFunction:
 
-      ClangASTContext *clang_ast_context =
-          ClangASTContext::GetScratch(thread.GetProcess()->GetTarget());
+      TypeSystemClang *clang_ast_context =
+          TypeSystemClang::GetScratch(thread.GetProcess()->GetTarget());
       CompilerType get_thread_item_info_return_type =
           clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
 
       get_thread_item_info_caller =
           m_get_thread_item_info_impl_code->MakeFunctionCaller(
               get_thread_item_info_return_type, get_thread_item_info_arglist,
               thread_sp, error);
       if (error.Fail() || get_thread_item_info_caller == nullptr) {

 AppleGetThreadItemInfoHandler::GetThreadItemInfo(Thread &thread,
                                                  tid_t thread_id,
                                                  addr_t page_to_free,
                                                  uint64_t page_to_free_size,
                                                  Status &error) {
   lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
   ProcessSP process_sp(thread.CalculateProcess());
   TargetSP target_sp(thread.CalculateTarget());
-  ClangASTContext *clang_ast_context = ClangASTContext::GetScratch(*target_sp);
+  TypeSystemClang *clang_ast_context = TypeSystemClang::GetScratch(*target_sp);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
 
   GetThreadItemInfoReturnInfo return_value;
   return_value.item_buffer_ptr = LLDB_INVALID_ADDRESS;
   return_value.item_buffer_size = 0;
 
   error.Clear();
 

lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

 //===-- SystemRuntimeMacOSX.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 "Plugins/Process/Utility/HistoryThread.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/Queue.h"
 #include "lldb/Target/QueueList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
#if 0
             uint16_t version = m_process->GetTarget().ReadUnsignedIntegerFromMemory (dti_struct_addr, false, 2, UINT16_MAX, error);
             if (error.Success() && dti_version != UINT16_MAX)
             {
                 dti_version = version;
             }
         }
 #endif
 
-    ClangASTContext *ast_ctx =
-        ClangASTContext::GetScratch(m_process->GetTarget());
+    TypeSystemClang *ast_ctx =
+        TypeSystemClang::GetScratch(m_process->GetTarget());
     if (m_dispatch_tsd_indexes_addr != LLDB_INVALID_ADDRESS) {
       CompilerType uint16 =
           ast_ctx->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 16);
       CompilerType dispatch_tsd_indexes_s = ast_ctx->CreateRecordType(
           nullptr, lldb::eAccessPublic, "__lldb_dispatch_tsd_indexes_s",
           clang::TTK_Struct, lldb::eLanguageTypeC);
 
-      ClangASTContext::StartTagDeclarationDefinition(dispatch_tsd_indexes_s);
-      ClangASTContext::AddFieldToRecordType(dispatch_tsd_indexes_s,
+      TypeSystemClang::StartTagDeclarationDefinition(dispatch_tsd_indexes_s);
+      TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s,
                                             "dti_version", uint16,
                                             lldb::eAccessPublic, 0);
-      ClangASTContext::AddFieldToRecordType(dispatch_tsd_indexes_s,
+      TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s,
                                             "dti_queue_index", uint16,
                                             lldb::eAccessPublic, 0);
-      ClangASTContext::AddFieldToRecordType(dispatch_tsd_indexes_s,
+      TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s,
                                             "dti_voucher_index", uint16,
                                             lldb::eAccessPublic, 0);
-      ClangASTContext::AddFieldToRecordType(dispatch_tsd_indexes_s,
+      TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s,
                                             "dti_qos_class_index", uint16,
                                             lldb::eAccessPublic, 0);
-      ClangASTContext::CompleteTagDeclarationDefinition(dispatch_tsd_indexes_s);
+      TypeSystemClang::CompleteTagDeclarationDefinition(dispatch_tsd_indexes_s);
 
       ProcessStructReader struct_reader(m_process, m_dispatch_tsd_indexes_addr,
                                         dispatch_tsd_indexes_s);
 
       m_libdispatch_tsd_indexes.dti_version =
           struct_reader.GetField<uint16_t>(ConstString("dti_version"));
       m_libdispatch_tsd_indexes.dti_queue_index =
           struct_reader.GetField<uint16_t>(ConstString("dti_queue_index"));

lldb/source/Symbol/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES LocateSymbolFileMacOSX.cpp)
 
 if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   set(PLATFORM_SOURCES LocateSymbolFileMacOSX.cpp)
 endif()
 
 add_lldb_library(lldbSymbol
   ArmUnwindInfo.cpp
   Block.cpp
-  ClangASTContext.cpp
+  TypeSystemClang.cpp
   ClangASTImporter.cpp
   ClangASTMetadata.cpp
   ClangExternalASTSourceCallbacks.cpp
   ClangUtil.cpp
   CompactUnwindInfo.cpp
   CompileUnit.cpp
   CompilerDecl.cpp
   CompilerDeclContext.cpp

lldb/source/Symbol/ClangASTImporter.cpp

 //===-- ClangASTImporter.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 "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangASTMetadata.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <memory>
 
 using namespace lldb_private;
 using namespace clang;
 
-CompilerType ClangASTImporter::CopyType(ClangASTContext &dst_ast,
+CompilerType ClangASTImporter::CopyType(TypeSystemClang &dst_ast,
                                         const CompilerType &src_type) {
   clang::ASTContext &dst_clang_ast = dst_ast.getASTContext();
 
-  ClangASTContext *src_ast =
-      llvm::dyn_cast_or_null<ClangASTContext>(src_type.GetTypeSystem());
+  TypeSystemClang *src_ast =
+      llvm::dyn_cast_or_null<TypeSystemClang>(src_type.GetTypeSystem());
   if (!src_ast)
     return CompilerType();
 
   clang::ASTContext &src_clang_ast = src_ast->getASTContext();
 
   clang::QualType src_qual_type = ClangUtil::GetQualType(src_type);
 
   ImporterDelegateSP delegate_sp(GetDelegate(&dst_clang_ast, &src_clang_ast));
while (!m_decls_to_complete.empty()) {
       m_decls_already_completed.insert(decl);
 
       // We should only complete decls coming from the source context.
       assert(to_context_md->m_origins[decl].ctx == m_src_ctx);
 
       Decl *original_decl = to_context_md->m_origins[decl].decl;
 
       // Complete the decl now.
-      ClangASTContext::GetCompleteDecl(m_src_ctx, original_decl);
+      TypeSystemClang::GetCompleteDecl(m_src_ctx, original_decl);
       if (auto *tag_decl = dyn_cast<TagDecl>(decl)) {
         if (auto *original_tag_decl = dyn_cast<TagDecl>(original_decl)) {
           if (original_tag_decl->isCompleteDefinition()) {
             m_delegate->ImportDefinitionTo(tag_decl, original_tag_decl);
             tag_decl->setCompleteDefinition(true);
           }
         }
 
void NewDeclImported(clang::Decl *from, clang::Decl *to) override {
     // Check if we already completed this type.
     if (m_decls_already_completed.count(to_named_decl) != 0)
       return;
     m_decls_to_complete.push_back(to_named_decl);
   }
 };
 } // namespace
 
-CompilerType ClangASTImporter::DeportType(ClangASTContext &dst,
+CompilerType ClangASTImporter::DeportType(TypeSystemClang &dst,
                                           const CompilerType &src_type) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-  ClangASTContext *src_ctxt =
-      llvm::cast<ClangASTContext>(src_type.GetTypeSystem());
+  TypeSystemClang *src_ctxt =
+      llvm::cast<TypeSystemClang>(src_type.GetTypeSystem());
 
   LLDB_LOG(log,
            "    [ClangASTImporter] DeportType called on ({0}Type*){1:x} "
            "from (ASTContext*){2:x} to (ASTContext*){3:x}",
            src_type.GetTypeName(), src_type.GetOpaqueQualType(),
            &src_ctxt->getASTContext(), &dst.getASTContext());
 
   DeclContextOverride decl_context_override;
bool ClangASTImporter::Import(const CompilerType &type) {
   return false;
 }
 
 bool ClangASTImporter::CompleteType(const CompilerType &compiler_type) {
   if (!CanImport(compiler_type))
     return false;
 
   if (Import(compiler_type)) {
-    ClangASTContext::CompleteTagDeclarationDefinition(compiler_type);
+    TypeSystemClang::CompleteTagDeclarationDefinition(compiler_type);
     return true;
   }
 
-  ClangASTContext::SetHasExternalStorage(compiler_type.GetOpaqueQualType(),
+  TypeSystemClang::SetHasExternalStorage(compiler_type.GetOpaqueQualType(),
                                          false);
   return false;
 }
 
 bool ClangASTImporter::LayoutRecordType(
     const clang::RecordDecl *record_decl, uint64_t &bit_size,
     uint64_t &alignment,
     llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,

 }
 
 bool ClangASTImporter::CompleteTagDecl(clang::TagDecl *decl) {
   DeclOrigin decl_origin = GetDeclOrigin(decl);
 
   if (!decl_origin.Valid())
     return false;
 
-  if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
+  if (!TypeSystemClang::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
     return false;
 
   ImporterDelegateSP delegate_sp(
       GetDelegate(&decl->getASTContext(), decl_origin.ctx));
 
   ASTImporterDelegate::CxxModuleScope std_scope(*delegate_sp,
                                                 &decl->getASTContext());
   if (delegate_sp)
     delegate_sp->ImportDefinitionTo(decl, decl_origin.decl);
 
   return true;
 }
 
 bool ClangASTImporter::CompleteTagDeclWithOrigin(clang::TagDecl *decl,
                                                  clang::TagDecl *origin_decl) {
   clang::ASTContext *origin_ast_ctx = &origin_decl->getASTContext();
 
-  if (!ClangASTContext::GetCompleteDecl(origin_ast_ctx, origin_decl))
+  if (!TypeSystemClang::GetCompleteDecl(origin_ast_ctx, origin_decl))
     return false;
 
   ImporterDelegateSP delegate_sp(
       GetDelegate(&decl->getASTContext(), origin_ast_ctx));
 
   if (delegate_sp)
     delegate_sp->ImportDefinitionTo(decl, origin_decl);
 
   ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
 
   OriginMap &origins = context_md->m_origins;
 
   origins[decl] = DeclOrigin(origin_ast_ctx, origin_decl);
 
   return true;
 }
 
 bool ClangASTImporter::CompleteObjCInterfaceDecl(
     clang::ObjCInterfaceDecl *interface_decl) {
   DeclOrigin decl_origin = GetDeclOrigin(interface_decl);
 
   if (!decl_origin.Valid())
     return false;
 
-  if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
+  if (!TypeSystemClang::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
     return false;
 
   ImporterDelegateSP delegate_sp(
       GetDelegate(&interface_decl->getASTContext(), decl_origin.ctx));
 
   if (delegate_sp)
     delegate_sp->ImportDefinitionTo(interface_decl, decl_origin.decl);
 
bool ClangASTImporter::RequireCompleteType(clang::QualType type) {
 
   return true;
 }
 
 ClangASTMetadata *ClangASTImporter::GetDeclMetadata(const clang::Decl *decl) {
   DeclOrigin decl_origin = GetDeclOrigin(decl);
 
   if (decl_origin.Valid()) {
-    ClangASTContext *ast = ClangASTContext::GetASTContext(decl_origin.ctx);
+    TypeSystemClang *ast = TypeSystemClang::GetASTContext(decl_origin.ctx);
     return ast->GetMetadata(decl_origin.decl);
   }
-  ClangASTContext *ast = ClangASTContext::GetASTContext(&decl->getASTContext());
+  TypeSystemClang *ast = TypeSystemClang::GetASTContext(&decl->getASTContext());
   return ast->GetMetadata(decl);
 }
 
 ClangASTImporter::DeclOrigin
 ClangASTImporter::GetDeclOrigin(const clang::Decl *decl) {
   ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
 
   OriginMap &origins = context_md->m_origins;

lldb/source/Symbol/ClangExternalASTSourceCallbacks.cpp

 //===-- ClangExternalASTSourceCallbacks.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 "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 
 #include "clang/AST/Decl.h"
 
 using namespace lldb_private;
 
 void ClangExternalASTSourceCallbacks::CompleteType(clang::TagDecl *tag_decl) {
   m_ast.CompleteTagDecl(tag_decl);
 }

lldb/source/Symbol/ClangUtil.cpp

 //===-- ClangUtil.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
 //
 // A collection of helper methods and data structures for manipulating clang
 // types and decls.
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/ClangUtil.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 
 using namespace clang;
 using namespace lldb_private;
 
 bool ClangUtil::IsClangType(const CompilerType &ct) {
   // Invalid types are never Clang types.
   if (!ct)
     return false;
 
-  if (llvm::dyn_cast_or_null<ClangASTContext>(ct.GetTypeSystem()) == nullptr)
+  if (llvm::dyn_cast_or_null<TypeSystemClang>(ct.GetTypeSystem()) == nullptr)
     return false;
 
   if (!ct.GetOpaqueQualType())
     return false;
 
   return true;
 }
 

lldb/source/Symbol/CxxModuleHandler.cpp

 //===-- CxxModuleHandler.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 "lldb/Symbol/CxxModuleHandler.h"
 
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Utility/Log.h"
 #include "clang/Sema/Lookup.h"
 #include "llvm/Support/Error.h"
 
 using namespace lldb_private;
 using namespace clang;
 
 CxxModuleHandler::CxxModuleHandler(ASTImporter &importer, ASTContext *target)
     : m_importer(&importer),
-      m_sema(ClangASTContext::GetASTContext(target)->getSema()) {
+      m_sema(TypeSystemClang::GetASTContext(target)->getSema()) {
 
   std::initializer_list<const char *> supported_names = {
       // containers
       "deque",
       "forward_list",
       "list",
       "queue",
       "stack",

lldb/source/Symbol/Type.cpp

if (!m_compiler_type.IsValid()) {
     } else {
       // We have no encoding type, return void?
       auto type_system_or_err =
           m_symbol_file->GetTypeSystemForLanguage(eLanguageTypeC);
       if (auto err = type_system_or_err.takeError()) {
         LLDB_LOG_ERROR(
             lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
             std::move(err),
-            "Unable to construct void type from ClangASTContext");
+            "Unable to construct void type from TypeSystemClang");
       } else {
         CompilerType void_compiler_type =
             type_system_or_err->GetBasicTypeFromAST(eBasicTypeVoid);
         switch (m_encoding_uid_type) {
         case eEncodingIsUID:
           m_compiler_type = void_compiler_type;
           break;
 

lldb/source/Symbol/TypeSystemClang.cpp

-//===-- ClangASTContext.cpp -------------------------------------*- C++ -*-===//
+//===-- TypeSystemClang.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 "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/FormatVariadic.h"
 
 #include <mutex>
 #include <string>
 #include <vector>
 

 #ifdef LLDB_CONFIGURATION_DEBUG
 static void VerifyDecl(clang::Decl *decl) {
   assert(decl && "VerifyDecl called with nullptr?");
   decl->getAccess();
 }
 #endif
 
 static inline bool
-ClangASTContextSupportsLanguage(lldb::LanguageType language) {
+TypeSystemClangSupportsLanguage(lldb::LanguageType language) {
   return language == eLanguageTypeUnknown || // Clang is the default type system
          lldb_private::Language::LanguageIsC(language) ||
          lldb_private::Language::LanguageIsCPlusPlus(language) ||
          lldb_private::Language::LanguageIsObjC(language) ||
          lldb_private::Language::LanguageIsPascal(language) ||
          // Use Clang for Rust until there is a proper language plugin for it
          language == eLanguageTypeRust ||
          language == eLanguageTypeExtRenderScript ||
static bool GetVBaseBitOffset(VTableContextBase &vtable_ctx,
   if (base_offset == INT64_MAX)
     return false;
 
   bit_offset = base_offset * 8;
 
   return true;
 }
 
-typedef lldb_private::ThreadSafeDenseMap<clang::ASTContext *, ClangASTContext *>
+typedef lldb_private::ThreadSafeDenseMap<clang::ASTContext *, TypeSystemClang *>
     ClangASTMap;
 
 static ClangASTMap &GetASTMap() {
   static ClangASTMap *g_map_ptr = nullptr;
   static llvm::once_flag g_once_flag;
   llvm::call_once(g_once_flag, []() {
     g_map_ptr = new ClangASTMap(); // leaked on purpose to avoid spins
   });
   return *g_map_ptr;
 }
 
-char ClangASTContext::ID;
+char TypeSystemClang::ID;
 
-bool ClangASTContext::IsOperator(llvm::StringRef name,
+bool TypeSystemClang::IsOperator(llvm::StringRef name,
                                  clang::OverloadedOperatorKind &op_kind) {
   // All operators have to start with "operator".
   if (!name.consume_front("operator"))
     return false;
 
   // Remember if there was a space after "operator". This is necessary to
   // check for collisions with strangely named functions like "operatorint()".
   bool space_after_operator = name.consume_front(" ");
op_kind = StringSwitch<clang::OverloadedOperatorKind>(name)
                 .Case("delete[]", clang::OO_Array_Delete)
                 // conversion operators hit this case.
                 .Default(clang::NUM_OVERLOADED_OPERATORS);
 
   return true;
 }
 
 clang::AccessSpecifier
-ClangASTContext::ConvertAccessTypeToAccessSpecifier(AccessType access) {
+TypeSystemClang::ConvertAccessTypeToAccessSpecifier(AccessType access) {
   switch (access) {
   default:
     break;
   case eAccessNone:
     return AS_none;
   case eAccessPublic:
     return AS_public;
   case eAccessPrivate:
static void ParseLangArgs(LangOptions &Opts, InputKind IK, const char *triple) {
   // This is the __NO_INLINE__ define, which just depends on things like the
   // optimization level and -fno-inline, not actually whether the backend has
   // inlining enabled.
   //
   // FIXME: This is affected by other options (-fno-inline).
   Opts.NoInlineDefine = !Opt;
 }
 
-ClangASTContext::ClangASTContext(llvm::StringRef name,
+TypeSystemClang::TypeSystemClang(llvm::StringRef name,
                                  llvm::Triple target_triple) {
   m_display_name = name.str();
   if (!target_triple.str().empty())
     SetTargetTriple(target_triple.str());
   // The caller didn't pass an ASTContext so create a new one for this
-  // ClangASTContext.
+  // TypeSystemClang.
   CreateASTContext();
 }
 
-ClangASTContext::ClangASTContext(llvm::StringRef name,
+TypeSystemClang::TypeSystemClang(llvm::StringRef name,
                                  ASTContext &existing_ctxt) {
   m_display_name = name.str();
   SetTargetTriple(existing_ctxt.getTargetInfo().getTriple().str());
 
   m_ast_up.reset(&existing_ctxt);
   GetASTMap().Insert(&existing_ctxt, this);
 }
 
 // Destructor
-ClangASTContext::~ClangASTContext() { Finalize(); }
+TypeSystemClang::~TypeSystemClang() { Finalize(); }
 
-ConstString ClangASTContext::GetPluginNameStatic() {
+ConstString TypeSystemClang::GetPluginNameStatic() {
   return ConstString("clang");
 }
 
-ConstString ClangASTContext::GetPluginName() {
-  return ClangASTContext::GetPluginNameStatic();
+ConstString TypeSystemClang::GetPluginName() {
+  return TypeSystemClang::GetPluginNameStatic();
 }
 
-uint32_t ClangASTContext::GetPluginVersion() { return 1; }
+uint32_t TypeSystemClang::GetPluginVersion() { return 1; }
 
-lldb::TypeSystemSP ClangASTContext::CreateInstance(lldb::LanguageType language,
+lldb::TypeSystemSP TypeSystemClang::CreateInstance(lldb::LanguageType language,
                                                    lldb_private::Module *module,
                                                    Target *target) {
-  if (!ClangASTContextSupportsLanguage(language))
+  if (!TypeSystemClangSupportsLanguage(language))
     return lldb::TypeSystemSP();
   ArchSpec arch;
   if (module)
     arch = module->GetArchitecture();
   else if (target)
     arch = target->GetArchitecture();
 
   if (!arch.IsValid())
if (triple.getVendor() == llvm::Triple::Apple &&
     } else {
       triple.setOS(llvm::Triple::MacOSX);
     }
   }
 
   if (module) {
     std::string ast_name =
         "ASTContext for '" + module->GetFileSpec().GetPath() + "'";
-    return std::make_shared<ClangASTContext>(ast_name, triple);
+    return std::make_shared<TypeSystemClang>(ast_name, triple);
   } else if (target && target->IsValid())
-    return std::make_shared<ClangASTContextForExpressions>(*target, triple);
+    return std::make_shared<TypeSystemClangForExpressions>(*target, triple);
   return lldb::TypeSystemSP();
 }
 
-LanguageSet ClangASTContext::GetSupportedLanguagesForTypes() {
+LanguageSet TypeSystemClang::GetSupportedLanguagesForTypes() {
   LanguageSet languages;
   languages.Insert(lldb::eLanguageTypeC89);
   languages.Insert(lldb::eLanguageTypeC);
   languages.Insert(lldb::eLanguageTypeC11);
   languages.Insert(lldb::eLanguageTypeC_plus_plus);
   languages.Insert(lldb::eLanguageTypeC99);
   languages.Insert(lldb::eLanguageTypeObjC);
   languages.Insert(lldb::eLanguageTypeObjC_plus_plus);
   languages.Insert(lldb::eLanguageTypeC_plus_plus_03);
   languages.Insert(lldb::eLanguageTypeC_plus_plus_11);
   languages.Insert(lldb::eLanguageTypeC11);
   languages.Insert(lldb::eLanguageTypeC_plus_plus_14);
   return languages;
 }
 
-LanguageSet ClangASTContext::GetSupportedLanguagesForExpressions() {
+LanguageSet TypeSystemClang::GetSupportedLanguagesForExpressions() {
   LanguageSet languages;
   languages.Insert(lldb::eLanguageTypeC_plus_plus);
   languages.Insert(lldb::eLanguageTypeObjC_plus_plus);
   languages.Insert(lldb::eLanguageTypeC_plus_plus_03);
   languages.Insert(lldb::eLanguageTypeC_plus_plus_11);
   languages.Insert(lldb::eLanguageTypeC_plus_plus_14);
   return languages;
 }
 
-void ClangASTContext::Initialize() {
+void TypeSystemClang::Initialize() {
   PluginManager::RegisterPlugin(
       GetPluginNameStatic(), "clang base AST context plug-in", CreateInstance,
       GetSupportedLanguagesForTypes(), GetSupportedLanguagesForExpressions());
 }
 
-void ClangASTContext::Terminate() {
+void TypeSystemClang::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
-void ClangASTContext::Finalize() {
+void TypeSystemClang::Finalize() {
   assert(m_ast_up);
   GetASTMap().Erase(m_ast_up.get());
   if (!m_ast_owned)
     m_ast_up.release();
 
   m_builtins_up.reset();
   m_selector_table_up.reset();
   m_identifier_table_up.reset();
   m_target_info_up.reset();
   m_target_options_rp.reset();
   m_diagnostics_engine_up.reset();
   m_source_manager_up.reset();
   m_language_options_up.reset();
 }
 
-void ClangASTContext::setSema(Sema *s) {
+void TypeSystemClang::setSema(Sema *s) {
   // Ensure that the new sema actually belongs to our ASTContext.
   assert(s == nullptr || &s->getASTContext() == m_ast_up.get());
   m_sema = s;
 }
 
-const char *ClangASTContext::GetTargetTriple() {
+const char *TypeSystemClang::GetTargetTriple() {
   return m_target_triple.c_str();
 }
 
-void ClangASTContext::SetTargetTriple(llvm::StringRef target_triple) {
+void TypeSystemClang::SetTargetTriple(llvm::StringRef target_triple) {
   m_target_triple = target_triple.str();
 }
 
-void ClangASTContext::SetExternalSource(
+void TypeSystemClang::SetExternalSource(
     llvm::IntrusiveRefCntPtr<ExternalASTSource> &ast_source_up) {
   ASTContext &ast = getASTContext();
   ast.setExternalSource(ast_source_up);
   ast.getTranslationUnitDecl()->setHasExternalLexicalStorage(true);
 }
 
-ASTContext &ClangASTContext::getASTContext() {
+ASTContext &TypeSystemClang::getASTContext() {
   assert(m_ast_up);
   return *m_ast_up;
 }
 
 class NullDiagnosticConsumer : public DiagnosticConsumer {
 public:
   NullDiagnosticConsumer() {
     m_log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
public:
   DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
     return new NullDiagnosticConsumer();
   }
 
 private:
   Log *m_log;
 };
 
-void ClangASTContext::CreateASTContext() {
+void TypeSystemClang::CreateASTContext() {
   assert(!m_ast_up);
   m_ast_owned = true;
 
   m_language_options_up.reset(new LangOptions());
   ParseLangArgs(*m_language_options_up, clang::Language::ObjCXX,
                 GetTargetTriple());
 
   m_identifier_table_up.reset(
void TypeSystemClang::CreateASTContext() {
 
   GetASTMap().Insert(m_ast_up.get(), this);
 
   llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_up(
       new ClangExternalASTSourceCallbacks(*this));
   SetExternalSource(ast_source_up);
 }
 
-ClangASTContext *ClangASTContext::GetASTContext(clang::ASTContext *ast) {
-  ClangASTContext *clang_ast = GetASTMap().Lookup(ast);
+TypeSystemClang *TypeSystemClang::GetASTContext(clang::ASTContext *ast) {
+  TypeSystemClang *clang_ast = GetASTMap().Lookup(ast);
   return clang_ast;
 }
 
-clang::MangleContext *ClangASTContext::getMangleContext() {
+clang::MangleContext *TypeSystemClang::getMangleContext() {
   if (m_mangle_ctx_up == nullptr)
     m_mangle_ctx_up.reset(getASTContext().createMangleContext());
   return m_mangle_ctx_up.get();
 }
 
-std::shared_ptr<clang::TargetOptions> &ClangASTContext::getTargetOptions() {
+std::shared_ptr<clang::TargetOptions> &TypeSystemClang::getTargetOptions() {
   if (m_target_options_rp == nullptr && !m_target_triple.empty()) {
     m_target_options_rp = std::make_shared<clang::TargetOptions>();
     if (m_target_options_rp != nullptr)
       m_target_options_rp->Triple = m_target_triple;
   }
   return m_target_options_rp;
 }
 
-TargetInfo *ClangASTContext::getTargetInfo() {
+TargetInfo *TypeSystemClang::getTargetInfo() {
   // target_triple should be something like "x86_64-apple-macosx"
   if (m_target_info_up == nullptr && !m_target_triple.empty())
     m_target_info_up.reset(TargetInfo::CreateTargetInfo(
         getASTContext().getDiagnostics(), getTargetOptions()));
   return m_target_info_up.get();
 }
 
 #pragma mark Basic Types
 
 static inline bool QualTypeMatchesBitSize(const uint64_t bit_size,
                                           ASTContext &ast, QualType qual_type) {
   uint64_t qual_type_bit_size = ast.getTypeSize(qual_type);
   return qual_type_bit_size == bit_size;
 }
 
 CompilerType
-ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(Encoding encoding,
+TypeSystemClang::GetBuiltinTypeForEncodingAndBitSize(Encoding encoding,
                                                      size_t bit_size) {
   ASTContext &ast = getASTContext();
   switch (encoding) {
   case eEncodingInvalid:
     if (QualTypeMatchesBitSize(bit_size, ast, ast.VoidPtrTy))
       return GetType(ast.VoidPtrTy);
     break;
 
if (bit_size && !(bit_size & 0x7u))
       return GetType(ast.getExtVectorType(ast.UnsignedCharTy, bit_size / 8));
     break;
   }
 
   return CompilerType();
 }
 
 lldb::BasicType
-ClangASTContext::GetBasicTypeEnumeration(ConstString name) {
+TypeSystemClang::GetBasicTypeEnumeration(ConstString name) {
   if (name) {
     typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
     static TypeNameToBasicTypeMap g_type_map;
     static llvm::once_flag g_once_flag;
     llvm::call_once(g_once_flag, []() {
       // "void"
       g_type_map.Append(ConstString("void"), eBasicTypeVoid);
 
llvm::call_once(g_once_flag, []() {
       g_type_map.Sort();
     });
 
     return g_type_map.Find(name, eBasicTypeInvalid);
   }
   return eBasicTypeInvalid;
 }
 
-uint32_t ClangASTContext::GetPointerByteSize() {
+uint32_t TypeSystemClang::GetPointerByteSize() {
   if (m_pointer_byte_size == 0)
     if (auto size = GetBasicType(lldb::eBasicTypeVoid)
                         .GetPointerType()
                         .GetByteSize(nullptr))
       m_pointer_byte_size = *size;
   return m_pointer_byte_size;
 }
 
-CompilerType ClangASTContext::GetBasicType(lldb::BasicType basic_type) {
+CompilerType TypeSystemClang::GetBasicType(lldb::BasicType basic_type) {
   clang::ASTContext &ast = getASTContext();
 
   lldb::opaque_compiler_type_t clang_type =
       GetOpaqueCompilerType(&ast, basic_type);
 
   if (clang_type)
     return CompilerType(this, clang_type);
   return CompilerType();
 }
 
-CompilerType ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize(
+CompilerType TypeSystemClang::GetBuiltinTypeForDWARFEncodingAndBitSize(
     llvm::StringRef type_name, uint32_t dw_ate, uint32_t bit_size) {
   ASTContext &ast = getASTContext();
 
   switch (dw_ate) {
   default:
     break;
 
   case DW_ATE_address:
if (!type_name.empty()) {
     Host::SystemLog(Host::eSystemLogError, "error: need to add support for "
                                            "DW_TAG_base_type encoded with "
                                            "DW_ATE = 0x%x, bit_size = %u\n",
                     dw_ate, bit_size);
   }
   return CompilerType();
 }
 
-CompilerType ClangASTContext::GetCStringType(bool is_const) {
+CompilerType TypeSystemClang::GetCStringType(bool is_const) {
   ASTContext &ast = getASTContext();
   QualType char_type(ast.CharTy);
 
   if (is_const)
     char_type.addConst();
 
   return GetType(ast.getPointerType(char_type));
 }
 
-bool ClangASTContext::AreTypesSame(CompilerType type1, CompilerType type2,
+bool TypeSystemClang::AreTypesSame(CompilerType type1, CompilerType type2,
                                    bool ignore_qualifiers) {
-  ClangASTContext *ast =
-      llvm::dyn_cast_or_null<ClangASTContext>(type1.GetTypeSystem());
+  TypeSystemClang *ast =
+      llvm::dyn_cast_or_null<TypeSystemClang>(type1.GetTypeSystem());
   if (!ast || ast != type2.GetTypeSystem())
     return false;
 
   if (type1.GetOpaqueQualType() == type2.GetOpaqueQualType())
     return true;
 
   QualType type1_qual = ClangUtil::GetQualType(type1);
   QualType type2_qual = ClangUtil::GetQualType(type2);
 
   if (ignore_qualifiers) {
     type1_qual = type1_qual.getUnqualifiedType();
     type2_qual = type2_qual.getUnqualifiedType();
   }
 
   return ast->getASTContext().hasSameType(type1_qual, type2_qual);
 }
 
-CompilerType ClangASTContext::GetTypeForDecl(void *opaque_decl) {
+CompilerType TypeSystemClang::GetTypeForDecl(void *opaque_decl) {
   if (!opaque_decl)
     return CompilerType();
 
   clang::Decl *decl = static_cast<clang::Decl *>(opaque_decl);
   if (auto *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl))
     return GetTypeForDecl(named_decl);
   return CompilerType();
 }
 
-CompilerDeclContext ClangASTContext::CreateDeclContext(DeclContext *ctx) {
+CompilerDeclContext TypeSystemClang::CreateDeclContext(DeclContext *ctx) {
   // Check that the DeclContext actually belongs to this ASTContext.
   assert(&ctx->getParentASTContext() == &getASTContext());
   return CompilerDeclContext(this, ctx);
 }
 
-CompilerType ClangASTContext::GetTypeForDecl(clang::NamedDecl *decl) {
+CompilerType TypeSystemClang::GetTypeForDecl(clang::NamedDecl *decl) {
   if (clang::ObjCInterfaceDecl *interface_decl =
       llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
     return GetTypeForDecl(interface_decl);
   if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
     return GetTypeForDecl(tag_decl);
   return CompilerType();
 }
 
-CompilerType ClangASTContext::GetTypeForDecl(TagDecl *decl) {
+CompilerType TypeSystemClang::GetTypeForDecl(TagDecl *decl) {
   return GetType(getASTContext().getTagDeclType(decl));
 }
 
-CompilerType ClangASTContext::GetTypeForDecl(ObjCInterfaceDecl *decl) {
+CompilerType TypeSystemClang::GetTypeForDecl(ObjCInterfaceDecl *decl) {
   return GetType(getASTContext().getObjCInterfaceType(decl));
 }
 
 #pragma mark Structure, Unions, Classes
 
-CompilerType ClangASTContext::CreateRecordType(DeclContext *decl_ctx,
+CompilerType TypeSystemClang::CreateRecordType(DeclContext *decl_ctx,
                                                AccessType access_type,
                                                llvm::StringRef name, int kind,
                                                LanguageType language,
                                                ClangASTMetadata *metadata,
                                                bool exports_symbols) {
   ASTContext &ast = getASTContext();
 
   if (decl_ctx == nullptr)

 namespace {
   bool IsValueParam(const clang::TemplateArgument &argument) {
     return argument.getKind() == TemplateArgument::Integral;
   }
 }
 
 static TemplateParameterList *CreateTemplateParameterList(
     ASTContext *ast,
-    const ClangASTContext::TemplateParameterInfos &template_param_infos,
+    const TypeSystemClang::TemplateParameterInfos &template_param_infos,
     llvm::SmallVector<NamedDecl *, 8> &template_param_decls) {
   const bool parameter_pack = false;
   const bool is_typename = false;
   const unsigned depth = 0;
   const size_t num_template_params = template_param_infos.args.size();
   DeclContext *const decl_context =
       ast->getTranslationUnitDecl(); // Is this the right decl context?,
   for (size_t i = 0; i < num_template_params; ++i) {
static TemplateParameterList *CreateTemplateParameterList(
   }
   clang::Expr *const requires_clause = nullptr; // TODO: Concepts
   TemplateParameterList *template_param_list = TemplateParameterList::Create(
       *ast, SourceLocation(), SourceLocation(), template_param_decls,
       SourceLocation(), requires_clause);
   return template_param_list;
 }
 
-clang::FunctionTemplateDecl *ClangASTContext::CreateFunctionTemplateDecl(
+clang::FunctionTemplateDecl *TypeSystemClang::CreateFunctionTemplateDecl(
     clang::DeclContext *decl_ctx, clang::FunctionDecl *func_decl,
     const char *name, const TemplateParameterInfos &template_param_infos) {
   //    /// Create a function template node.
   ASTContext &ast = getASTContext();
 
   llvm::SmallVector<NamedDecl *, 8> template_param_decls;
 
   TemplateParameterList *template_param_list = CreateTemplateParameterList(
clang::FunctionTemplateDecl *TypeSystemClang::CreateFunctionTemplateDecl(
   // It doesn't matter what access specifier we give the template as LLDB
   // anyway allows accessing everything inside a record.
   if (decl_ctx->isRecord())
     func_tmpl_decl->setAccess(clang::AccessSpecifier::AS_public);
 
   return func_tmpl_decl;
 }
 
-void ClangASTContext::CreateFunctionTemplateSpecializationInfo(
+void TypeSystemClang::CreateFunctionTemplateSpecializationInfo(
     FunctionDecl *func_decl, clang::FunctionTemplateDecl *func_tmpl_decl,
     const TemplateParameterInfos &infos) {
   TemplateArgumentList *template_args_ptr =
       TemplateArgumentList::CreateCopy(func_decl->getASTContext(), infos.args);
 
   func_decl->setFunctionTemplateSpecialization(func_tmpl_decl,
                                                template_args_ptr, nullptr);
 }
 
-ClassTemplateDecl *ClangASTContext::CreateClassTemplateDecl(
+ClassTemplateDecl *TypeSystemClang::CreateClassTemplateDecl(
     DeclContext *decl_ctx, lldb::AccessType access_type, const char *class_name,
     int kind, const TemplateParameterInfos &template_param_infos) {
   ASTContext &ast = getASTContext();
 
   ClassTemplateDecl *class_template_decl = nullptr;
   if (decl_ctx == nullptr)
     decl_ctx = ast.getTranslationUnitDecl();
 
#ifdef LLDB_CONFIGURATION_DEBUG
     VerifyDecl(class_template_decl);
 #endif
   }
 
   return class_template_decl;
 }
 
 TemplateTemplateParmDecl *
-ClangASTContext::CreateTemplateTemplateParmDecl(const char *template_name) {
+TypeSystemClang::CreateTemplateTemplateParmDecl(const char *template_name) {
   ASTContext &ast = getASTContext();
 
   auto *decl_ctx = ast.getTranslationUnitDecl();
 
   IdentifierInfo &identifier_info = ast.Idents.get(template_name);
   llvm::SmallVector<NamedDecl *, 8> template_param_decls;
 
-  ClangASTContext::TemplateParameterInfos template_param_infos;
+  TypeSystemClang::TemplateParameterInfos template_param_infos;
   TemplateParameterList *template_param_list = CreateTemplateParameterList(
       &ast, template_param_infos, template_param_decls);
 
   // LLDB needs to create those decls only to be able to display a
   // type that includes a template template argument. Only the name matters for
   // this purpose, so we use dummy values for the other characterisitcs of the
   // type.
   return TemplateTemplateParmDecl::Create(
       ast, decl_ctx, SourceLocation(),
       /*Depth*/ 0, /*Position*/ 0,
       /*IsParameterPack*/ false, &identifier_info, template_param_list);
 }
 
 ClassTemplateSpecializationDecl *
-ClangASTContext::CreateClassTemplateSpecializationDecl(
+TypeSystemClang::CreateClassTemplateSpecializationDecl(
     DeclContext *decl_ctx, ClassTemplateDecl *class_template_decl, int kind,
     const TemplateParameterInfos &template_param_infos) {
   ASTContext &ast = getASTContext();
   llvm::SmallVector<clang::TemplateArgument, 2> args(
       template_param_infos.args.size() +
       (template_param_infos.packed_args ? 1 : 0));
   std::copy(template_param_infos.args.begin(), template_param_infos.args.end(),
             args.begin());
   if (template_param_infos.packed_args) {
     args[args.size() - 1] = TemplateArgument::CreatePackCopy(
         ast, template_param_infos.packed_args->args);
   }
   ClassTemplateSpecializationDecl *class_template_specialization_decl =
       ClassTemplateSpecializationDecl::Create(
           ast, (TagDecl::TagKind)kind, decl_ctx, SourceLocation(),
           SourceLocation(), class_template_decl, args, nullptr);
 
   class_template_specialization_decl->setSpecializationKind(
       TSK_ExplicitSpecialization);
 
   return class_template_specialization_decl;
 }
 
-CompilerType ClangASTContext::CreateClassTemplateSpecializationType(
+CompilerType TypeSystemClang::CreateClassTemplateSpecializationType(
     ClassTemplateSpecializationDecl *class_template_specialization_decl) {
   if (class_template_specialization_decl) {
     ASTContext &ast = getASTContext();
     return GetType(ast.getTagDeclType(class_template_specialization_decl));
   }
   return CompilerType();
 }
 
static inline bool check_op_param(bool is_method,
   if (num_params == 1)
     return unary;
   if (num_params == 2)
     return binary;
   else
     return false;
 }
 
-bool ClangASTContext::CheckOverloadedOperatorKindParameterCount(
+bool TypeSystemClang::CheckOverloadedOperatorKindParameterCount(
     bool is_method, clang::OverloadedOperatorKind op_kind,
     uint32_t num_params) {
   switch (op_kind) {
   default:
     break;
   // C++ standard allows any number of arguments to new/delete
   case OO_New:
   case OO_Array_New:

 #include "clang/Basic/OperatorKinds.def"
   default:
     break;
   }
   return false;
 }
 
 clang::AccessSpecifier
-ClangASTContext::UnifyAccessSpecifiers(clang::AccessSpecifier lhs,
+TypeSystemClang::UnifyAccessSpecifiers(clang::AccessSpecifier lhs,
                                        clang::AccessSpecifier rhs) {
   // Make the access equal to the stricter of the field and the nested field's
   // access
   if (lhs == AS_none || rhs == AS_none)
     return AS_none;
   if (lhs == AS_private || rhs == AS_private)
     return AS_private;
   if (lhs == AS_protected || rhs == AS_protected)
     return AS_protected;
   return AS_public;
 }
 
-bool ClangASTContext::FieldIsBitfield(FieldDecl *field,
+bool TypeSystemClang::FieldIsBitfield(FieldDecl *field,
                                       uint32_t &bitfield_bit_size) {
   ASTContext &ast = getASTContext();
   if (field == nullptr)
     return false;
 
   if (field->isBitField()) {
     Expr *bit_width_expr = field->getBitWidth();
     if (bit_width_expr) {
       llvm::APSInt bit_width_apsint;
       if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, ast)) {
         bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX);
         return true;
       }
     }
   }
   return false;
 }
 
-bool ClangASTContext::RecordHasFields(const RecordDecl *record_decl) {
+bool TypeSystemClang::RecordHasFields(const RecordDecl *record_decl) {
   if (record_decl == nullptr)
     return false;
 
   if (!record_decl->field_empty())
     return true;
 
   // No fields, lets check this is a CXX record and check the base classes
   const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
   if (cxx_record_decl) {
     CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
     for (base_class = cxx_record_decl->bases_begin(),
         base_class_end = cxx_record_decl->bases_end();
          base_class != base_class_end; ++base_class) {
       const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(
           base_class->getType()->getAs<RecordType>()->getDecl());
       if (RecordHasFields(base_class_decl))
         return true;
     }
   }
   return false;
 }
 
 #pragma mark Objective-C Classes
 
-CompilerType ClangASTContext::CreateObjCClass(llvm::StringRef name,
+CompilerType TypeSystemClang::CreateObjCClass(llvm::StringRef name,
                                               DeclContext *decl_ctx,
                                               bool isForwardDecl,
                                               bool isInternal,
                                               ClangASTMetadata *metadata) {
   ASTContext &ast = getASTContext();
   assert(!name.empty());
   if (decl_ctx == nullptr)
     decl_ctx = ast.getTranslationUnitDecl();
 
   ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create(
       ast, decl_ctx, SourceLocation(), &ast.Idents.get(name), nullptr, nullptr,
       SourceLocation(),
       /*isForwardDecl,*/
       isInternal);
 
   if (decl && metadata)
     SetMetadata(decl, *metadata);
 
   return GetType(ast.getObjCInterfaceType(decl));
 }
 
 static inline bool BaseSpecifierIsEmpty(const CXXBaseSpecifier *b) {
-  return !ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl());
+  return !TypeSystemClang::RecordHasFields(b->getType()->getAsCXXRecordDecl());
 }
 
 uint32_t
-ClangASTContext::GetNumBaseClasses(const CXXRecordDecl *cxx_record_decl,
+TypeSystemClang::GetNumBaseClasses(const CXXRecordDecl *cxx_record_decl,
                                    bool omit_empty_base_classes) {
   uint32_t num_bases = 0;
   if (cxx_record_decl) {
     if (omit_empty_base_classes) {
       CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
       for (base_class = cxx_record_decl->bases_begin(),
           base_class_end = cxx_record_decl->bases_end();
            base_class != base_class_end; ++base_class) {
         // Skip empty base classes
         if (omit_empty_base_classes) {
           if (BaseSpecifierIsEmpty(base_class))
             continue;
         }
         ++num_bases;
       }
     } else
       num_bases = cxx_record_decl->getNumBases();
   }
   return num_bases;
 }
 
 #pragma mark Namespace Declarations
 
-NamespaceDecl *ClangASTContext::GetUniqueNamespaceDeclaration(
+NamespaceDecl *TypeSystemClang::GetUniqueNamespaceDeclaration(
     const char *name, DeclContext *decl_ctx, bool is_inline) {
   NamespaceDecl *namespace_decl = nullptr;
   ASTContext &ast = getASTContext();
   TranslationUnitDecl *translation_unit_decl = ast.getTranslationUnitDecl();
   if (decl_ctx == nullptr)
     decl_ctx = translation_unit_decl;
 
   if (name) {
NamespaceDecl *TypeSystemClang::GetUniqueNamespaceDeclaration(
   }
 #ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(namespace_decl);
 #endif
   return namespace_decl;
 }
 
 clang::BlockDecl *
-ClangASTContext::CreateBlockDeclaration(clang::DeclContext *ctx) {
+TypeSystemClang::CreateBlockDeclaration(clang::DeclContext *ctx) {
   if (ctx != nullptr) {
     clang::BlockDecl *decl =
         clang::BlockDecl::Create(getASTContext(), ctx, clang::SourceLocation());
     ctx->addDecl(decl);
     return decl;
   }
   return nullptr;
 }
clang::DeclContext *FindLCABetweenDecls(clang::DeclContext *left,
 
   for (clang::DeclContext *d = right; d != nullptr; d = d->getParent())
     if (path_left.find(d) != path_left.end())
       return d;
 
   return nullptr;
 }
 
-clang::UsingDirectiveDecl *ClangASTContext::CreateUsingDirectiveDeclaration(
+clang::UsingDirectiveDecl *TypeSystemClang::CreateUsingDirectiveDeclaration(
     clang::DeclContext *decl_ctx, clang::NamespaceDecl *ns_decl) {
   if (decl_ctx != nullptr && ns_decl != nullptr) {
     auto *translation_unit = getASTContext().getTranslationUnitDecl();
     clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create(
         getASTContext(), decl_ctx, clang::SourceLocation(),
         clang::SourceLocation(), clang::NestedNameSpecifierLoc(),
         clang::SourceLocation(), ns_decl,
         FindLCABetweenDecls(decl_ctx, ns_decl, translation_unit));
     decl_ctx->addDecl(using_decl);
     return using_decl;
   }
   return nullptr;
 }
 
 clang::UsingDecl *
-ClangASTContext::CreateUsingDeclaration(clang::DeclContext *current_decl_ctx,
+TypeSystemClang::CreateUsingDeclaration(clang::DeclContext *current_decl_ctx,
                                         clang::NamedDecl *target) {
   if (current_decl_ctx != nullptr && target != nullptr) {
     clang::UsingDecl *using_decl = clang::UsingDecl::Create(
         getASTContext(), current_decl_ctx, clang::SourceLocation(),
         clang::NestedNameSpecifierLoc(), clang::DeclarationNameInfo(), false);
     clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create(
         getASTContext(), current_decl_ctx, clang::SourceLocation(), using_decl,
         target);
     using_decl->addShadowDecl(shadow_decl);
     current_decl_ctx->addDecl(using_decl);
     return using_decl;
   }
   return nullptr;
 }
 
-clang::VarDecl *ClangASTContext::CreateVariableDeclaration(
+clang::VarDecl *TypeSystemClang::CreateVariableDeclaration(
     clang::DeclContext *decl_context, const char *name, clang::QualType type) {
   if (decl_context != nullptr) {
     clang::VarDecl *var_decl = clang::VarDecl::Create(
         getASTContext(), decl_context, clang::SourceLocation(),
         clang::SourceLocation(),
         name && name[0] ? &getASTContext().Idents.getOwn(name) : nullptr, type,
         nullptr, clang::SC_None);
     var_decl->setAccess(clang::AS_public);
     decl_context->addDecl(var_decl);
     return var_decl;
   }
   return nullptr;
 }
 
 lldb::opaque_compiler_type_t
-ClangASTContext::GetOpaqueCompilerType(clang::ASTContext *ast,
+TypeSystemClang::GetOpaqueCompilerType(clang::ASTContext *ast,
                                        lldb::BasicType basic_type) {
   switch (basic_type) {
   case eBasicTypeVoid:
     return ast->VoidTy.getAsOpaquePtr();
   case eBasicTypeChar:
     return ast->CharTy.getAsOpaquePtr();
   case eBasicTypeSignedChar:
     return ast->SignedCharTy.getAsOpaquePtr();
TypeSystemClang::GetOpaqueCompilerType(clang::ASTContext *ast,
   default:
     return nullptr;
   }
 }
 
 #pragma mark Function Types
 
 clang::DeclarationName
-ClangASTContext::GetDeclarationName(const char *name,
+TypeSystemClang::GetDeclarationName(const char *name,
                                     const CompilerType &function_clang_type) {
   if (!name || !name[0])
     return clang::DeclarationName();
 
   clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
   if (!IsOperator(name, op_kind) || op_kind == clang::NUM_OVERLOADED_OPERATORS)
     return DeclarationName(&getASTContext().Idents.get(
         name)); // Not operator, but a regular function.
 
   // Check the number of operator parameters. Sometimes we have seen bad DWARF
   // that doesn't correctly describe operators and if we try to create a method
   // and add it to the class, clang will assert and crash, so we need to make
   // sure things are acceptable.
   clang::QualType method_qual_type(ClangUtil::GetQualType(function_clang_type));
   const clang::FunctionProtoType *function_type =
       llvm::dyn_cast<clang::FunctionProtoType>(method_qual_type.getTypePtr());
   if (function_type == nullptr)
     return clang::DeclarationName();
 
   const bool is_method = false;
   const unsigned int num_params = function_type->getNumParams();
-  if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount(
+  if (!TypeSystemClang::CheckOverloadedOperatorKindParameterCount(
           is_method, op_kind, num_params))
     return clang::DeclarationName();
 
   return getASTContext().DeclarationNames.getCXXOperatorName(op_kind);
 }
 
-FunctionDecl *ClangASTContext::CreateFunctionDeclaration(
+FunctionDecl *TypeSystemClang::CreateFunctionDeclaration(
     DeclContext *decl_ctx, const char *name,
     const CompilerType &function_clang_type, int storage, bool is_inline) {
   FunctionDecl *func_decl = nullptr;
   ASTContext &ast = getASTContext();
   if (decl_ctx == nullptr)
     decl_ctx = ast.getTranslationUnitDecl();
 
   const bool hasWrittenPrototype = true;

 #ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(func_decl);
 #endif
 
   return func_decl;
 }
 
 CompilerType
-ClangASTContext::CreateFunctionType(const CompilerType &result_type,
+TypeSystemClang::CreateFunctionType(const CompilerType &result_type,
                                     const CompilerType *args, unsigned num_args,
                                     bool is_variadic, unsigned type_quals,
                                     clang::CallingConv cc) {
   if (!result_type || !ClangUtil::IsClangType(result_type))
     return CompilerType(); // invalid return type
 
   std::vector<QualType> qual_type_args;
   if (num_args > 0 && args == nullptr)
TypeSystemClang::CreateFunctionType(const CompilerType &result_type,
   proto_info.ExceptionSpec = EST_None;
   proto_info.TypeQuals = clang::Qualifiers::fromFastMask(type_quals);
   proto_info.RefQualifier = RQ_None;
 
   return GetType(getASTContext().getFunctionType(
       ClangUtil::GetQualType(result_type), qual_type_args, proto_info));
 }
 
-ParmVarDecl *ClangASTContext::CreateParameterDeclaration(
+ParmVarDecl *TypeSystemClang::CreateParameterDeclaration(
     clang::DeclContext *decl_ctx, const char *name,
     const CompilerType &param_type, int storage, bool add_decl) {
   ASTContext &ast = getASTContext();
   auto *decl =
       ParmVarDecl::Create(ast, decl_ctx, SourceLocation(), SourceLocation(),
                           name && name[0] ? &ast.Idents.get(name) : nullptr,
                           ClangUtil::GetQualType(param_type), nullptr,
                           (clang::StorageClass)storage, nullptr);
   if (add_decl)
     decl_ctx->addDecl(decl);
 
   return decl;
 }
 
-void ClangASTContext::SetFunctionParameters(FunctionDecl *function_decl,
+void TypeSystemClang::SetFunctionParameters(FunctionDecl *function_decl,
                                             ParmVarDecl **params,
                                             unsigned num_params) {
   if (function_decl)
     function_decl->setParams(ArrayRef<ParmVarDecl *>(params, num_params));
 }
 
 CompilerType
-ClangASTContext::CreateBlockPointerType(const CompilerType &function_type) {
+TypeSystemClang::CreateBlockPointerType(const CompilerType &function_type) {
   QualType block_type = m_ast_up->getBlockPointerType(
       clang::QualType::getFromOpaquePtr(function_type.GetOpaqueQualType()));
 
   return GetType(block_type);
 }
 
 #pragma mark Array Types
 
-CompilerType ClangASTContext::CreateArrayType(const CompilerType &element_type,
+CompilerType TypeSystemClang::CreateArrayType(const CompilerType &element_type,
                                               size_t element_count,
                                               bool is_vector) {
   if (element_type.IsValid()) {
     ASTContext &ast = getASTContext();
 
     if (is_vector) {
       return GetType(ast.getExtVectorType(ClangUtil::GetQualType(element_type),
                                           element_count));
     } else {
 
       llvm::APInt ap_element_count(64, element_count);
       if (element_count == 0) {
         return GetType(ast.getIncompleteArrayType(
             ClangUtil::GetQualType(element_type), clang::ArrayType::Normal, 0));
       } else {
         return GetType(ast.getConstantArrayType(
             ClangUtil::GetQualType(element_type), ap_element_count, nullptr,
             clang::ArrayType::Normal, 0));
       }
     }
   }
   return CompilerType();
 }
 
-CompilerType ClangASTContext::CreateStructForIdentifier(
+CompilerType TypeSystemClang::CreateStructForIdentifier(
     ConstString type_name,
     const std::initializer_list<std::pair<const char *, CompilerType>>
         &type_fields,
     bool packed) {
   CompilerType type;
   if (!type_name.IsEmpty() &&
       (type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name))
           .IsValid()) {
     lldbassert(0 && "Trying to create a type for an existing name");
     return type;
   }
 
   type = CreateRecordType(nullptr, lldb::eAccessPublic, type_name.GetCString(),
                           clang::TTK_Struct, lldb::eLanguageTypeC);
   StartTagDeclarationDefinition(type);
   for (const auto &field : type_fields)
     AddFieldToRecordType(type, field.first, field.second, lldb::eAccessPublic,
                          0);
   if (packed)
     SetIsPacked(type);
   CompleteTagDeclarationDefinition(type);
   return type;
 }
 
-CompilerType ClangASTContext::GetOrCreateStructForIdentifier(
+CompilerType TypeSystemClang::GetOrCreateStructForIdentifier(
     ConstString type_name,
     const std::initializer_list<std::pair<const char *, CompilerType>>
         &type_fields,
     bool packed) {
   CompilerType type;
   if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid())
     return type;
 
   return CreateStructForIdentifier(type_name, type_fields, packed);
 }
 
 #pragma mark Enumeration Types
 
 CompilerType
-ClangASTContext::CreateEnumerationType(const char *name, DeclContext *decl_ctx,
+TypeSystemClang::CreateEnumerationType(const char *name, DeclContext *decl_ctx,
                                        const Declaration &decl,
                                        const CompilerType &integer_clang_type,
                                        bool is_scoped) {
   // TODO: Do something intelligent with the Declaration object passed in
   // like maybe filling in the SourceLocation with it...
   ASTContext &ast = getASTContext();
 
   // TODO: ask about these...
if (enum_decl) {
 
     enum_decl->setAccess(AS_public); // TODO respect what's in the debug info
 
     return GetType(ast.getTagDeclType(enum_decl));
   }
   return CompilerType();
 }
 
-CompilerType ClangASTContext::GetIntTypeFromBitSize(size_t bit_size,
+CompilerType TypeSystemClang::GetIntTypeFromBitSize(size_t bit_size,
                                                     bool is_signed) {
   clang::ASTContext &ast = getASTContext();
 
   if (is_signed) {
     if (bit_size == ast.getTypeSize(ast.SignedCharTy))
       return GetType(ast.SignedCharTy);
 
     if (bit_size == ast.getTypeSize(ast.ShortTy))
if (bit_size == ast.getTypeSize(ast.UnsignedLongLongTy))
       return GetType(ast.UnsignedLongLongTy);
 
     if (bit_size == ast.getTypeSize(ast.UnsignedInt128Ty))
       return GetType(ast.UnsignedInt128Ty);
   }
   return CompilerType();
 }
 
-CompilerType ClangASTContext::GetPointerSizedIntType(bool is_signed) {
+CompilerType TypeSystemClang::GetPointerSizedIntType(bool is_signed) {
   return GetIntTypeFromBitSize(
       getASTContext().getTypeSize(getASTContext().VoidPtrTy), is_signed);
 }
 
-void ClangASTContext::DumpDeclContextHiearchy(clang::DeclContext *decl_ctx) {
+void TypeSystemClang::DumpDeclContextHiearchy(clang::DeclContext *decl_ctx) {
   if (decl_ctx) {
     DumpDeclContextHiearchy(decl_ctx->getParent());
 
     clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl_ctx);
     if (named_decl) {
       printf("%20s: %s\n", decl_ctx->getDeclKindName(),
              named_decl->getDeclName().getAsString().c_str());
     } else {
       printf("%20s\n", decl_ctx->getDeclKindName());
     }
   }
 }
 
-void ClangASTContext::DumpDeclHiearchy(clang::Decl *decl) {
+void TypeSystemClang::DumpDeclHiearchy(clang::Decl *decl) {
   if (decl == nullptr)
     return;
   DumpDeclContextHiearchy(decl->getDeclContext());
 
   clang::RecordDecl *record_decl = llvm::dyn_cast<clang::RecordDecl>(decl);
   if (record_decl) {
     printf("%20s: %s%s\n", decl->getDeclKindName(),
            record_decl->getDeclName().getAsString().c_str(),
            record_decl->isInjectedClassName() ? " (injected class name)" : "");
 
   } else {
     clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl);
     if (named_decl) {
       printf("%20s: %s\n", decl->getDeclKindName(),
              named_decl->getDeclName().getAsString().c_str());
     } else {
       printf("%20s\n", decl->getDeclKindName());
     }
   }
 }
 
-bool ClangASTContext::DeclsAreEquivalent(clang::Decl *lhs_decl,
+bool TypeSystemClang::DeclsAreEquivalent(clang::Decl *lhs_decl,
                                          clang::Decl *rhs_decl) {
   if (lhs_decl && rhs_decl) {
     // Make sure the decl kinds match first
     const clang::Decl::Kind lhs_decl_kind = lhs_decl->getKind();
     const clang::Decl::Kind rhs_decl_kind = rhs_decl->getKind();
 
     if (lhs_decl_kind == rhs_decl_kind) {
       // Now check that the decl contexts kinds are all equivalent before we
if (lhs_decl_kind == rhs_decl_kind) {
           lhs_decl_ctx = lhs_decl_ctx->getParent();
           rhs_decl_ctx = rhs_decl_ctx->getParent();
         }
       }
     }
   }
   return false;
 }
-bool ClangASTContext::GetCompleteDecl(clang::ASTContext *ast,
+bool TypeSystemClang::GetCompleteDecl(clang::ASTContext *ast,
                                       clang::Decl *decl) {
   if (!decl)
     return false;
 
   ExternalASTSource *ast_source = ast->getExternalSource();
 
   if (!ast_source)
     return false;
if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) {
     ast_source->CompleteType(objc_interface_decl);
 
     return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
   } else {
     return false;
   }
 }
 
-void ClangASTContext::SetMetadataAsUserID(const clang::Decl *decl,
+void TypeSystemClang::SetMetadataAsUserID(const clang::Decl *decl,
                                           user_id_t user_id) {
   ClangASTMetadata meta_data;
   meta_data.SetUserID(user_id);
   SetMetadata(decl, meta_data);
 }
 
-void ClangASTContext::SetMetadataAsUserID(const clang::Type *type,
+void TypeSystemClang::SetMetadataAsUserID(const clang::Type *type,
                                           user_id_t user_id) {
   ClangASTMetadata meta_data;
   meta_data.SetUserID(user_id);
   SetMetadata(type, meta_data);
 }
 
-void ClangASTContext::SetMetadata(const clang::Decl *object,
+void TypeSystemClang::SetMetadata(const clang::Decl *object,
                                   ClangASTMetadata &metadata) {
   m_decl_metadata[object] = metadata;
 }
 
-void ClangASTContext::SetMetadata(const clang::Type *object,
+void TypeSystemClang::SetMetadata(const clang::Type *object,
                                   ClangASTMetadata &metadata) {
   m_type_metadata[object] = metadata;
 }
 
-ClangASTMetadata *ClangASTContext::GetMetadata(const clang::Decl *object) {
+ClangASTMetadata *TypeSystemClang::GetMetadata(const clang::Decl *object) {
   auto It = m_decl_metadata.find(object);
   if (It != m_decl_metadata.end())
     return &It->second;
   return nullptr;
 }
 
-ClangASTMetadata *ClangASTContext::GetMetadata(const clang::Type *object) {
+ClangASTMetadata *TypeSystemClang::GetMetadata(const clang::Type *object) {
   auto It = m_type_metadata.find(object);
   if (It != m_type_metadata.end())
     return &It->second;
   return nullptr;
 }
 
-bool ClangASTContext::SetTagTypeKind(clang::QualType tag_qual_type,
+bool TypeSystemClang::SetTagTypeKind(clang::QualType tag_qual_type,
                                      int kind) const {
   const clang::Type *clang_type = tag_qual_type.getTypePtr();
   if (clang_type) {
     const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(clang_type);
     if (tag_type) {
       clang::TagDecl *tag_decl =
           llvm::dyn_cast<clang::TagDecl>(tag_type->getDecl());
       if (tag_decl) {
         tag_decl->setTagKind((clang::TagDecl::TagKind)kind);
         return true;
       }
     }
   }
   return false;
 }
 
-bool ClangASTContext::SetDefaultAccessForRecordFields(
+bool TypeSystemClang::SetDefaultAccessForRecordFields(
     clang::RecordDecl *record_decl, int default_accessibility,
     int *assigned_accessibilities, size_t num_assigned_accessibilities) {
   if (record_decl) {
     uint32_t field_idx;
     clang::RecordDecl::field_iterator field, field_end;
     for (field = record_decl->field_begin(),
         field_end = record_decl->field_end(), field_idx = 0;
          field != field_end; ++field, ++field_idx) {
       // If no accessibility was assigned, assign the correct one
       if (field_idx < num_assigned_accessibilities &&
           assigned_accessibilities[field_idx] == clang::AS_none)
         field->setAccess((clang::AccessSpecifier)default_accessibility);
     }
     return true;
   }
   return false;
 }
 
 clang::DeclContext *
-ClangASTContext::GetDeclContextForType(const CompilerType &type) {
+TypeSystemClang::GetDeclContextForType(const CompilerType &type) {
   return GetDeclContextForType(ClangUtil::GetQualType(type));
 }
 
 /// Aggressively desugar the provided type, skipping past various kinds of
 /// syntactic sugar and other constructs one typically wants to ignore.
 /// The \p mask argument allows one to skip certain kinds of simplifications,
 /// when one wishes to handle a certain kind of type directly.
 static QualType
case clang::Type::TypeOfExpr:
       break;
     default:
       return type;
     }
   }
 }
 
 clang::DeclContext *
-ClangASTContext::GetDeclContextForType(clang::QualType type) {
+TypeSystemClang::GetDeclContextForType(clang::QualType type) {
   if (type.isNull())
     return nullptr;
 
   clang::QualType qual_type = RemoveWrappingTypes(type.getCanonicalType());
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::ObjCInterface:
     return llvm::cast<clang::ObjCObjectType>(qual_type.getTypePtr())
ConvertAccessTypeToObjCIvarAccessControl(AccessType access) {
   case eAccessPackage:
     return clang::ObjCIvarDecl::Package;
   }
   return clang::ObjCIvarDecl::None;
 }
 
 // Tests
 
-bool ClangASTContext::IsAggregateType(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsAggregateType(lldb::opaque_compiler_type_t type) {
   clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
 
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::IncompleteArray:
   case clang::Type::VariableArray:
   case clang::Type::ConstantArray:
   case clang::Type::ExtVector:
   case clang::Type::Vector:
   case clang::Type::Record:
   case clang::Type::ObjCObject:
   case clang::Type::ObjCInterface:
     return true;
   default:
     break;
   }
   // The clang type does have a value
   return false;
 }
 
-bool ClangASTContext::IsAnonymousType(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsAnonymousType(lldb::opaque_compiler_type_t type) {
   clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
 
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record: {
     if (const clang::RecordType *record_type =
             llvm::dyn_cast_or_null<clang::RecordType>(
                 qual_type.getTypePtrOrNull())) {
       if (const clang::RecordDecl *record_decl = record_type->getDecl()) {
         return record_decl->isAnonymousStructOrUnion();
       }
     }
     break;
   }
   default:
     break;
   }
   // The clang type does have a value
   return false;
 }
 
-bool ClangASTContext::IsArrayType(lldb::opaque_compiler_type_t type,
+bool TypeSystemClang::IsArrayType(lldb::opaque_compiler_type_t type,
                                   CompilerType *element_type_ptr,
                                   uint64_t *size, bool *is_incomplete) {
   clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
 
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   default:
     break;
if (element_type_ptr)
     element_type_ptr->Clear();
   if (size)
     *size = 0;
   if (is_incomplete)
     *is_incomplete = false;
   return false;
 }
 
-bool ClangASTContext::IsVectorType(lldb::opaque_compiler_type_t type,
+bool TypeSystemClang::IsVectorType(lldb::opaque_compiler_type_t type,
                                    CompilerType *element_type, uint64_t *size) {
   clang::QualType qual_type(GetCanonicalQualType(type));
 
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Vector: {
     const clang::VectorType *vector_type =
         qual_type->getAs<clang::VectorType>();
case clang::Type::ExtVector: {
     return true;
   }
   default:
     break;
   }
   return false;
 }
 
-bool ClangASTContext::IsRuntimeGeneratedType(
+bool TypeSystemClang::IsRuntimeGeneratedType(
     lldb::opaque_compiler_type_t type) {
   clang::DeclContext *decl_ctx = GetDeclContextForType(GetQualType(type));
   if (!decl_ctx)
     return false;
 
   if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx))
     return false;
 
   clang::ObjCInterfaceDecl *result_iface_decl =
       llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);
 
   ClangASTMetadata *ast_metadata = GetMetadata(result_iface_decl);
   if (!ast_metadata)
     return false;
   return (ast_metadata->GetISAPtr() != 0);
 }
 
-bool ClangASTContext::IsCharType(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsCharType(lldb::opaque_compiler_type_t type) {
   return GetQualType(type).getUnqualifiedType()->isCharType();
 }
 
-bool ClangASTContext::IsCompleteType(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsCompleteType(lldb::opaque_compiler_type_t type) {
   const bool allow_completion = false;
   return GetCompleteQualType(&getASTContext(), GetQualType(type),
                              allow_completion);
 }
 
-bool ClangASTContext::IsConst(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsConst(lldb::opaque_compiler_type_t type) {
   return GetQualType(type).isConstQualified();
 }
 
-bool ClangASTContext::IsCStringType(lldb::opaque_compiler_type_t type,
+bool TypeSystemClang::IsCStringType(lldb::opaque_compiler_type_t type,
                                     uint32_t &length) {
   CompilerType pointee_or_element_clang_type;
   length = 0;
   Flags type_flags(GetTypeInfo(type, &pointee_or_element_clang_type));
 
   if (!pointee_or_element_clang_type.IsValid())
     return false;
 
   if (type_flags.AnySet(eTypeIsArray | eTypeIsPointer)) {
     if (pointee_or_element_clang_type.IsCharType()) {
       if (type_flags.Test(eTypeIsArray)) {
         // We know the size of the array and it could be a C string since it is
         // an array of characters
         length = llvm::cast<clang::ConstantArrayType>(
                      GetCanonicalQualType(type).getTypePtr())
                      ->getSize()
                      .getLimitedValue();
       }
       return true;
     }
   }
   return false;
 }
 
-bool ClangASTContext::IsFunctionType(lldb::opaque_compiler_type_t type,
+bool TypeSystemClang::IsFunctionType(lldb::opaque_compiler_type_t type,
                                      bool *is_variadic_ptr) {
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
     if (qual_type->isFunctionType()) {
       if (is_variadic_ptr) {
         const clang::FunctionProtoType *function_proto_type =
             llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
if (type) {
     } break;
     }
   }
   return false;
 }
 
 // Used to detect "Homogeneous Floating-point Aggregates"
 uint32_t
-ClangASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
+TypeSystemClang::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
                                         CompilerType *base_type_ptr) {
   if (!type)
     return 0;
 
   clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
case clang::Type::Record:
     break;
 
   default:
     break;
   }
   return 0;
 }
 
-size_t ClangASTContext::GetNumberOfFunctionArguments(
+size_t TypeSystemClang::GetNumberOfFunctionArguments(
     lldb::opaque_compiler_type_t type) {
   if (type) {
     clang::QualType qual_type(GetCanonicalQualType(type));
     const clang::FunctionProtoType *func =
         llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
     if (func)
       return func->getNumParams();
   }
   return 0;
 }
 
 CompilerType
-ClangASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
+TypeSystemClang::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
                                             const size_t index) {
   if (type) {
     clang::QualType qual_type(GetQualType(type));
     const clang::FunctionProtoType *func =
         llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
     if (func) {
       if (index < func->getNumParams())
         return CompilerType(this, func->getParamType(index).getAsOpaquePtr());
     }
   }
   return CompilerType();
 }
 
-bool ClangASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsFunctionPointerType(lldb::opaque_compiler_type_t type) {
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
     if (qual_type->isFunctionPointerType())
       return true;
 
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     default:
       break;
 
     case clang::Type::LValueReference:
     case clang::Type::RValueReference: {
       const clang::ReferenceType *reference_type =
           llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
       if (reference_type)
         return IsFunctionPointerType(
             reference_type->getPointeeType().getAsOpaquePtr());
     } break;
     }
   }
   return false;
 }
 
-bool ClangASTContext::IsBlockPointerType(
+bool TypeSystemClang::IsBlockPointerType(
     lldb::opaque_compiler_type_t type,
     CompilerType *function_pointer_type_ptr) {
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
     if (qual_type->isBlockPointerType()) {
       if (function_pointer_type_ptr) {
         const clang::BlockPointerType *block_pointer_type =
case clang::Type::RValueReference: {
             reference_type->getPointeeType().getAsOpaquePtr(),
             function_pointer_type_ptr);
     } break;
     }
   }
   return false;
 }
 
-bool ClangASTContext::IsIntegerType(lldb::opaque_compiler_type_t type,
+bool TypeSystemClang::IsIntegerType(lldb::opaque_compiler_type_t type,
                                     bool &is_signed) {
   if (!type)
     return false;
 
   clang::QualType qual_type(GetCanonicalQualType(type));
   const clang::BuiltinType *builtin_type =
       llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
 
   if (builtin_type) {
     if (builtin_type->isInteger()) {
       is_signed = builtin_type->isSignedInteger();
       return true;
     }
   }
 
   return false;
 }
 
-bool ClangASTContext::IsEnumerationType(lldb::opaque_compiler_type_t type,
+bool TypeSystemClang::IsEnumerationType(lldb::opaque_compiler_type_t type,
                                         bool &is_signed) {
   if (type) {
     const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
         GetCanonicalQualType(type)->getCanonicalTypeInternal());
 
     if (enum_type) {
       IsIntegerType(enum_type->getDecl()->getIntegerType().getAsOpaquePtr(),
                     is_signed);
       return true;
     }
   }
 
   return false;
 }
 
-bool ClangASTContext::IsPointerType(lldb::opaque_compiler_type_t type,
+bool TypeSystemClang::IsPointerType(lldb::opaque_compiler_type_t type,
                                     CompilerType *pointee_type) {
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::Builtin:
       switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
       default:
default:
       break;
     }
   }
   if (pointee_type)
     pointee_type->Clear();
   return false;
 }
 
-bool ClangASTContext::IsPointerOrReferenceType(
+bool TypeSystemClang::IsPointerOrReferenceType(
     lldb::opaque_compiler_type_t type, CompilerType *pointee_type) {
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::Builtin:
       switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
       default:
default:
       break;
     }
   }
   if (pointee_type)
     pointee_type->Clear();
   return false;
 }
 
-bool ClangASTContext::IsReferenceType(lldb::opaque_compiler_type_t type,
+bool TypeSystemClang::IsReferenceType(lldb::opaque_compiler_type_t type,
                                       CompilerType *pointee_type,
                                       bool *is_rvalue) {
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
 
     switch (type_class) {
     case clang::Type::LValueReference:
default:
       break;
     }
   }
   if (pointee_type)
     pointee_type->Clear();
   return false;
 }
 
-bool ClangASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type,
+bool TypeSystemClang::IsFloatingPointType(lldb::opaque_compiler_type_t type,
                                           uint32_t &count, bool &is_complex) {
   if (type) {
     clang::QualType qual_type(GetCanonicalQualType(type));
 
     if (const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>(
             qual_type->getCanonicalTypeInternal())) {
       clang::BuiltinType::Kind kind = BT->getKind();
       if (kind >= clang::BuiltinType::Float &&
if (const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>(
       }
     }
   }
   count = 0;
   is_complex = false;
   return false;
 }
 
-bool ClangASTContext::IsDefined(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsDefined(lldb::opaque_compiler_type_t type) {
   if (!type)
     return false;
 
   clang::QualType qual_type(GetQualType(type));
   const clang::TagType *tag_type =
       llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
   if (tag_type) {
     clang::TagDecl *tag_decl = tag_type->getDecl();
if (objc_class_type) {
       if (class_interface_decl)
         return class_interface_decl->getDefinition() != nullptr;
       return false;
     }
   }
   return true;
 }
 
-bool ClangASTContext::IsObjCClassType(const CompilerType &type) {
+bool TypeSystemClang::IsObjCClassType(const CompilerType &type) {
   if (ClangUtil::IsClangType(type)) {
     clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
 
     const clang::ObjCObjectPointerType *obj_pointer_type =
         llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
 
     if (obj_pointer_type)
       return obj_pointer_type->isObjCClassType();
   }
   return false;
 }
 
-bool ClangASTContext::IsObjCObjectOrInterfaceType(const CompilerType &type) {
+bool TypeSystemClang::IsObjCObjectOrInterfaceType(const CompilerType &type) {
   if (ClangUtil::IsClangType(type))
     return ClangUtil::GetCanonicalQualType(type)->isObjCObjectOrInterfaceType();
   return false;
 }
 
-bool ClangASTContext::IsClassType(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsClassType(lldb::opaque_compiler_type_t type) {
   if (!type)
     return false;
   clang::QualType qual_type(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   return (type_class == clang::Type::Record);
 }
 
-bool ClangASTContext::IsEnumType(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsEnumType(lldb::opaque_compiler_type_t type) {
   if (!type)
     return false;
   clang::QualType qual_type(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   return (type_class == clang::Type::Enum);
 }
 
-bool ClangASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsPolymorphicClass(lldb::opaque_compiler_type_t type) {
   if (type) {
     clang::QualType qual_type(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::Record:
       if (GetCompleteType(type)) {
         const clang::RecordType *record_type =
             llvm::cast<clang::RecordType>(qual_type.getTypePtr());
if (type) {
 
     default:
       break;
     }
   }
   return false;
 }
 
-bool ClangASTContext::IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
+bool TypeSystemClang::IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
                                             CompilerType *dynamic_pointee_type,
                                             bool check_cplusplus,
                                             bool check_objc) {
   clang::QualType pointee_qual_type;
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     bool success = false;
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
if (success) {
       }
     }
   }
   if (dynamic_pointee_type)
     dynamic_pointee_type->Clear();
   return false;
 }
 
-bool ClangASTContext::IsScalarType(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsScalarType(lldb::opaque_compiler_type_t type) {
   if (!type)
     return false;
 
   return (GetTypeInfo(type, nullptr) & eTypeIsScalar) != 0;
 }
 
-bool ClangASTContext::IsTypedefType(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsTypedefType(lldb::opaque_compiler_type_t type) {
   if (!type)
     return false;
   return GetQualType(type)->getTypeClass() == clang::Type::Typedef;
 }
 
-bool ClangASTContext::IsVoidType(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsVoidType(lldb::opaque_compiler_type_t type) {
   if (!type)
     return false;
   return GetCanonicalQualType(type)->isVoidType();
 }
 
-bool ClangASTContext::CanPassInRegisters(const CompilerType &type) {
+bool TypeSystemClang::CanPassInRegisters(const CompilerType &type) {
   if (auto *record_decl =
-      ClangASTContext::GetAsRecordDecl(type)) {
+      TypeSystemClang::GetAsRecordDecl(type)) {
     return record_decl->canPassInRegisters();
   }
   return false;
 }
 
-bool ClangASTContext::SupportsLanguage(lldb::LanguageType language) {
-  return ClangASTContextSupportsLanguage(language);
+bool TypeSystemClang::SupportsLanguage(lldb::LanguageType language) {
+  return TypeSystemClangSupportsLanguage(language);
 }
 
 Optional<std::string>
-ClangASTContext::GetCXXClassName(const CompilerType &type) {
+TypeSystemClang::GetCXXClassName(const CompilerType &type) {
   if (!type)
     return llvm::None;
 
   clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
   if (qual_type.isNull())
     return llvm::None;
 
   clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
   if (!cxx_record_decl)
     return llvm::None;
 
   return std::string(cxx_record_decl->getIdentifier()->getNameStart());
 }
 
-bool ClangASTContext::IsCXXClassType(const CompilerType &type) {
+bool TypeSystemClang::IsCXXClassType(const CompilerType &type) {
   if (!type)
     return false;
 
   clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
   return !qual_type.isNull() && qual_type->getAsCXXRecordDecl() != nullptr;
 }
 
-bool ClangASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::IsBeingDefined(lldb::opaque_compiler_type_t type) {
   if (!type)
     return false;
   clang::QualType qual_type(GetCanonicalQualType(type));
   const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type);
   if (tag_type)
     return tag_type->isBeingDefined();
   return false;
 }
 
-bool ClangASTContext::IsObjCObjectPointerType(const CompilerType &type,
+bool TypeSystemClang::IsObjCObjectPointerType(const CompilerType &type,
                                               CompilerType *class_type_ptr) {
   if (!ClangUtil::IsClangType(type))
     return false;
 
   clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
 
   if (!qual_type.isNull() && qual_type->isObjCObjectPointerType()) {
     if (class_type_ptr) {
bool TypeSystemClang::IsObjCObjectPointerType(const CompilerType &type,
   }
   if (class_type_ptr)
     class_type_ptr->Clear();
   return false;
 }
 
 // Type Completion
 
-bool ClangASTContext::GetCompleteType(lldb::opaque_compiler_type_t type) {
+bool TypeSystemClang::GetCompleteType(lldb::opaque_compiler_type_t type) {
   if (!type)
     return false;
   const bool allow_completion = true;
   return GetCompleteQualType(&getASTContext(), GetQualType(type),
                              allow_completion);
 }
 
-ConstString ClangASTContext::GetTypeName(lldb::opaque_compiler_type_t type) {
+ConstString TypeSystemClang::GetTypeName(lldb::opaque_compiler_type_t type) {
   std::string type_name;
   if (type) {
     clang::PrintingPolicy printing_policy(getASTContext().getPrintingPolicy());
     clang::QualType qual_type(GetQualType(type));
     printing_policy.SuppressTagKeyword = true;
     const clang::TypedefType *typedef_type =
         qual_type->getAs<clang::TypedefType>();
     if (typedef_type) {
       const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
       type_name = typedef_decl->getQualifiedNameAsString();
     } else {
       type_name = qual_type.getAsString(printing_policy);
     }
   }
   return ConstString(type_name);
 }
 
 uint32_t
-ClangASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type,
+TypeSystemClang::GetTypeInfo(lldb::opaque_compiler_type_t type,
                              CompilerType *pointee_or_element_clang_type) {
   if (!type)
     return 0;
 
   if (pointee_or_element_clang_type)
     pointee_or_element_clang_type->Clear();
 
   clang::QualType qual_type =
TypeSystemClang::GetTypeInfo(lldb::opaque_compiler_type_t type,
   }
   default:
     return 0;
   }
   return 0;
 }
 
 lldb::LanguageType
-ClangASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetMinimumLanguage(lldb::opaque_compiler_type_t type) {
   if (!type)
     return lldb::eLanguageTypeC;
 
   // If the type is a reference, then resolve it to what it refers to first:
   clang::QualType qual_type(GetCanonicalQualType(type).getNonReferenceType());
   if (qual_type->isAnyPointerType()) {
     if (qual_type->isObjCObjectPointerType())
       return lldb::eLanguageTypeObjC;
case clang::Type::Typedef:
                          ->getUnderlyingType())
           .GetMinimumLanguage();
     }
   }
   return lldb::eLanguageTypeC;
 }
 
 lldb::TypeClass
-ClangASTContext::GetTypeClass(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetTypeClass(lldb::opaque_compiler_type_t type) {
   if (!type)
     return lldb::eTypeClassInvalid;
 
   clang::QualType qual_type =
       RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef});
 
   switch (qual_type->getTypeClass()) {
   case clang::Type::Atomic:
case clang::Type::DependentAddressSpace:
     break;
   case clang::Type::MacroQualified:
     break;
   }
   // We don't know hot to display this type...
   return lldb::eTypeClassOther;
 }
 
-unsigned ClangASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) {
+unsigned TypeSystemClang::GetTypeQualifiers(lldb::opaque_compiler_type_t type) {
   if (type)
     return GetQualType(type).getQualifiers().getCVRQualifiers();
   return 0;
 }
 
 // Creating related types
 
 CompilerType
-ClangASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type,
+TypeSystemClang::GetArrayElementType(lldb::opaque_compiler_type_t type,
                                      uint64_t *stride) {
   if (type) {
     clang::QualType qual_type(GetQualType(type));
 
     const clang::Type *array_eletype =
         qual_type.getTypePtr()->getArrayElementTypeNoTypeQual();
 
     if (!array_eletype)
       return CompilerType();
 
     CompilerType element_type = GetType(clang::QualType(array_eletype, 0));
 
     // TODO: the real stride will be >= this value.. find the real one!
     if (stride)
       if (Optional<uint64_t> size = element_type.GetByteSize(nullptr))
         *stride = *size;
 
     return element_type;
   }
   return CompilerType();
 }
 
-CompilerType ClangASTContext::GetArrayType(lldb::opaque_compiler_type_t type,
+CompilerType TypeSystemClang::GetArrayType(lldb::opaque_compiler_type_t type,
                                            uint64_t size) {
   if (type) {
     clang::QualType qual_type(GetCanonicalQualType(type));
     clang::ASTContext &ast_ctx = getASTContext();
     if (size != 0)
       return GetType(ast_ctx.getConstantArrayType(
           qual_type, llvm::APInt(64, size), nullptr,
           clang::ArrayType::ArraySizeModifier::Normal, 0));
     else
       return GetType(ast_ctx.getIncompleteArrayType(
           qual_type, clang::ArrayType::ArraySizeModifier::Normal, 0));
   }
 
   return CompilerType();
 }
 
 CompilerType
-ClangASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetCanonicalType(lldb::opaque_compiler_type_t type) {
   if (type)
     return GetType(GetCanonicalQualType(type));
   return CompilerType();
 }
 
 static clang::QualType GetFullyUnqualifiedType_Impl(clang::ASTContext *ast,
                                                     clang::QualType qual_type) {
   if (qual_type->isPointerType())
     qual_type = ast->getPointerType(
         GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType()));
   else
     qual_type = qual_type.getUnqualifiedType();
   qual_type.removeLocalConst();
   qual_type.removeLocalRestrict();
   qual_type.removeLocalVolatile();
   return qual_type;
 }
 
 CompilerType
-ClangASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) {
   if (type)
     return GetType(
         GetFullyUnqualifiedType_Impl(&getASTContext(), GetQualType(type)));
   return CompilerType();
 }
 
-int ClangASTContext::GetFunctionArgumentCount(
+int TypeSystemClang::GetFunctionArgumentCount(
     lldb::opaque_compiler_type_t type) {
   if (type) {
     const clang::FunctionProtoType *func =
         llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType(type));
     if (func)
       return func->getNumParams();
   }
   return -1;
 }
 
-CompilerType ClangASTContext::GetFunctionArgumentTypeAtIndex(
+CompilerType TypeSystemClang::GetFunctionArgumentTypeAtIndex(
     lldb::opaque_compiler_type_t type, size_t idx) {
   if (type) {
     const clang::FunctionProtoType *func =
         llvm::dyn_cast<clang::FunctionProtoType>(GetQualType(type));
     if (func) {
       const uint32_t num_args = func->getNumParams();
       if (idx < num_args)
         return GetType(func->getParamType(idx));
     }
   }
   return CompilerType();
 }
 
 CompilerType
-ClangASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetFunctionReturnType(lldb::opaque_compiler_type_t type) {
   if (type) {
     clang::QualType qual_type(GetQualType(type));
     const clang::FunctionProtoType *func =
         llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
     if (func)
       return GetType(func->getReturnType());
   }
   return CompilerType();
 }
 
 size_t
-ClangASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) {
   size_t num_functions = 0;
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     switch (qual_type->getTypeClass()) {
     case clang::Type::Record:
       if (GetCompleteQualType(&getASTContext(), qual_type)) {
         const clang::RecordType *record_type =
             llvm::cast<clang::RecordType>(qual_type.getTypePtr());
if (type) {
     default:
       break;
     }
   }
   return num_functions;
 }
 
 TypeMemberFunctionImpl
-ClangASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
+TypeSystemClang::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
                                           size_t idx) {
   std::string name;
   MemberFunctionKind kind(MemberFunctionKind::eMemberFunctionKindUnknown);
   CompilerType clang_type;
   CompilerDecl clang_decl;
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     switch (qual_type->getTypeClass()) {
TypeSystemClang::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
 
   if (kind == eMemberFunctionKindUnknown)
     return TypeMemberFunctionImpl();
   else
     return TypeMemberFunctionImpl(clang_type, clang_decl, name, kind);
 }
 
 CompilerType
-ClangASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetNonReferenceType(lldb::opaque_compiler_type_t type) {
   if (type)
     return GetType(GetQualType(type).getNonReferenceType());
   return CompilerType();
 }
 
-CompilerType ClangASTContext::CreateTypedefType(
+CompilerType TypeSystemClang::CreateTypedefType(
     const CompilerType &type, const char *typedef_name,
     const CompilerDeclContext &compiler_decl_ctx) {
   if (type && typedef_name && typedef_name[0]) {
-    ClangASTContext *ast =
-        llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
+    TypeSystemClang *ast =
+        llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
     if (!ast)
       return CompilerType();
     clang::ASTContext &clang_ast = ast->getASTContext();
     clang::QualType qual_type(ClangUtil::GetQualType(type));
 
     clang::DeclContext *decl_ctx =
-        ClangASTContext::DeclContextGetAsDeclContext(compiler_decl_ctx);
+        TypeSystemClang::DeclContextGetAsDeclContext(compiler_decl_ctx);
     if (decl_ctx == nullptr)
       decl_ctx = ast->getASTContext().getTranslationUnitDecl();
 
     clang::TypedefDecl *decl = clang::TypedefDecl::Create(
         clang_ast, decl_ctx, clang::SourceLocation(), clang::SourceLocation(),
         &clang_ast.Idents.get(typedef_name),
         clang_ast.getTrivialTypeSourceInfo(qual_type));
 
     decl->setAccess(clang::AS_public); // TODO respect proper access specifier
 
     decl_ctx->addDecl(decl);
 
     // Get a uniqued clang::QualType for the typedef decl type
     return ast->GetType(clang_ast.getTypedefType(decl));
   }
   return CompilerType();
 }
 
 CompilerType
-ClangASTContext::GetPointeeType(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetPointeeType(lldb::opaque_compiler_type_t type) {
   if (type) {
     clang::QualType qual_type(GetQualType(type));
     return GetType(qual_type.getTypePtr()->getPointeeType());
   }
   return CompilerType();
 }
 
 CompilerType
-ClangASTContext::GetPointerType(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetPointerType(lldb::opaque_compiler_type_t type) {
   if (type) {
     clang::QualType qual_type(GetQualType(type));
 
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::ObjCObject:
     case clang::Type::ObjCInterface:
       return GetType(getASTContext().getObjCObjectPointerType(qual_type));
 
     default:
       return GetType(getASTContext().getPointerType(qual_type));
     }
   }
   return CompilerType();
 }
 
 CompilerType
-ClangASTContext::GetLValueReferenceType(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetLValueReferenceType(lldb::opaque_compiler_type_t type) {
   if (type)
     return GetType(getASTContext().getLValueReferenceType(GetQualType(type)));
   else
     return CompilerType();
 }
 
 CompilerType
-ClangASTContext::GetRValueReferenceType(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetRValueReferenceType(lldb::opaque_compiler_type_t type) {
   if (type)
     return GetType(getASTContext().getRValueReferenceType(GetQualType(type)));
   else
     return CompilerType();
 }
 
-CompilerType ClangASTContext::GetAtomicType(lldb::opaque_compiler_type_t type) {
+CompilerType TypeSystemClang::GetAtomicType(lldb::opaque_compiler_type_t type) {
   if (!type)
     return CompilerType();
   return GetType(getASTContext().getAtomicType(GetQualType(type)));
 }
 
 CompilerType
-ClangASTContext::AddConstModifier(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::AddConstModifier(lldb::opaque_compiler_type_t type) {
   if (type) {
     clang::QualType result(GetQualType(type));
     result.addConst();
     return GetType(result);
   }
   return CompilerType();
 }
 
 CompilerType
-ClangASTContext::AddVolatileModifier(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::AddVolatileModifier(lldb::opaque_compiler_type_t type) {
   if (type) {
     clang::QualType result(GetQualType(type));
     result.addVolatile();
     return GetType(result);
   }
   return CompilerType();
 }
 
 CompilerType
-ClangASTContext::AddRestrictModifier(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::AddRestrictModifier(lldb::opaque_compiler_type_t type) {
   if (type) {
     clang::QualType result(GetQualType(type));
     result.addRestrict();
     return GetType(result);
   }
   return CompilerType();
 }
 
 CompilerType
-ClangASTContext::CreateTypedef(lldb::opaque_compiler_type_t type,
+TypeSystemClang::CreateTypedef(lldb::opaque_compiler_type_t type,
                                const char *typedef_name,
                                const CompilerDeclContext &compiler_decl_ctx) {
   if (type) {
     clang::ASTContext &clang_ast = getASTContext();
     clang::QualType qual_type(GetQualType(type));
 
     clang::DeclContext *decl_ctx =
-        ClangASTContext::DeclContextGetAsDeclContext(compiler_decl_ctx);
+        TypeSystemClang::DeclContextGetAsDeclContext(compiler_decl_ctx);
     if (decl_ctx == nullptr)
       decl_ctx = getASTContext().getTranslationUnitDecl();
 
     clang::TypedefDecl *decl = clang::TypedefDecl::Create(
         clang_ast, decl_ctx, clang::SourceLocation(), clang::SourceLocation(),
         &clang_ast.Idents.get(typedef_name),
         clang_ast.getTrivialTypeSourceInfo(qual_type));
 
if (type) {
 
     // Get a uniqued clang::QualType for the typedef decl type
     return GetType(clang_ast.getTypedefType(decl));
   }
   return CompilerType();
 }
 
 CompilerType
-ClangASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetTypedefedType(lldb::opaque_compiler_type_t type) {
   if (type) {
     const clang::TypedefType *typedef_type =
         llvm::dyn_cast<clang::TypedefType>(GetQualType(type));
     if (typedef_type)
       return GetType(typedef_type->getDecl()->getUnderlyingType());
   }
   return CompilerType();
 }
 
 // Create related types using the current type's AST
 
-CompilerType ClangASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) {
-  return ClangASTContext::GetBasicType(basic_type);
+CompilerType TypeSystemClang::GetBasicTypeFromAST(lldb::BasicType basic_type) {
+  return TypeSystemClang::GetBasicType(basic_type);
 }
 // Exploring the type
 
 const llvm::fltSemantics &
-ClangASTContext::GetFloatTypeSemantics(size_t byte_size) {
+TypeSystemClang::GetFloatTypeSemantics(size_t byte_size) {
   clang::ASTContext &ast = getASTContext();
   const size_t bit_size = byte_size * 8;
   if (bit_size == ast.getTypeSize(ast.FloatTy))
     return ast.getFloatTypeSemantics(ast.FloatTy);
   else if (bit_size == ast.getTypeSize(ast.DoubleTy))
     return ast.getFloatTypeSemantics(ast.DoubleTy);
   else if (bit_size == ast.getTypeSize(ast.LongDoubleTy))
     return ast.getFloatTypeSemantics(ast.LongDoubleTy);
   else if (bit_size == ast.getTypeSize(ast.HalfTy))
     return ast.getFloatTypeSemantics(ast.HalfTy);
   return llvm::APFloatBase::Bogus();
 }
 
 Optional<uint64_t>
-ClangASTContext::GetBitSize(lldb::opaque_compiler_type_t type,
+TypeSystemClang::GetBitSize(lldb::opaque_compiler_type_t type,
                             ExecutionContextScope *exe_scope) {
   if (GetCompleteType(type)) {
     clang::QualType qual_type(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::Record:
       if (GetCompleteType(type))
         return getASTContext().getTypeSize(qual_type);
default:
       if (bit_size)
         return bit_size;
     }
   }
   return None;
 }
 
 llvm::Optional<size_t>
-ClangASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type,
+TypeSystemClang::GetTypeBitAlign(lldb::opaque_compiler_type_t type,
                                  ExecutionContextScope *exe_scope) {
   if (GetCompleteType(type))
     return getASTContext().getTypeAlign(GetQualType(type));
   return {};
 }
 
-lldb::Encoding ClangASTContext::GetEncoding(lldb::opaque_compiler_type_t type,
+lldb::Encoding TypeSystemClang::GetEncoding(lldb::opaque_compiler_type_t type,
                                             uint64_t &count) {
   if (!type)
     return lldb::eEncodingInvalid;
 
   count = 1;
   clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
   switch (qual_type->getTypeClass()) {
case clang::Type::DependentAddressSpace:
     break;
   case clang::Type::MacroQualified:
     break;
   }
   count = 0;
   return lldb::eEncodingInvalid;
 }
 
-lldb::Format ClangASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
+lldb::Format TypeSystemClang::GetFormat(lldb::opaque_compiler_type_t type) {
   if (!type)
     return lldb::eFormatDefault;
 
   clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
   switch (qual_type->getTypeClass()) {
   case clang::Type::Atomic:
   case clang::Type::Auto:
if (check_superclass)
       class_interface_decl = class_interface_decl->getSuperClass();
     else
       break;
   }
   return false;
 }
 
 static Optional<SymbolFile::ArrayInfo>
-GetDynamicArrayInfo(ClangASTContext &ast, SymbolFile *sym_file,
+GetDynamicArrayInfo(TypeSystemClang &ast, SymbolFile *sym_file,
                     clang::QualType qual_type,
                     const ExecutionContext *exe_ctx) {
   if (qual_type->isIncompleteArrayType())
     if (auto *metadata = ast.GetMetadata(qual_type.getTypePtr()))
       return sym_file->GetDynamicArrayInfoForUID(metadata->GetUserID(),
                                                  exe_ctx);
   return llvm::None;
 }
 
-uint32_t ClangASTContext::GetNumChildren(lldb::opaque_compiler_type_t type,
+uint32_t TypeSystemClang::GetNumChildren(lldb::opaque_compiler_type_t type,
                                          bool omit_empty_base_classes,
                                          const ExecutionContext *exe_ctx) {
   if (!type)
     return 0;
 
   uint32_t num_children = 0;
   clang::QualType qual_type(RemoveWrappingTypes(GetQualType(type)));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
if (GetCompleteQualType(&getASTContext(), qual_type)) {
                base_class != base_class_end; ++base_class) {
             const clang::CXXRecordDecl *base_class_decl =
                 llvm::cast<clang::CXXRecordDecl>(
                     base_class->getType()
                         ->getAs<clang::RecordType>()
                         ->getDecl());
 
             // Skip empty base classes
-            if (!ClangASTContext::RecordHasFields(base_class_decl))
+            if (!TypeSystemClang::RecordHasFields(base_class_decl))
               continue;
 
             num_children++;
           }
         } else {
           // Include all base classes
           num_children += cxx_record_decl->getNumBases();
         }
uint32_t TypeSystemClang::GetNumChildren(lldb::opaque_compiler_type_t type,
   } break;
 
   default:
     break;
   }
   return num_children;
 }
 
-CompilerType ClangASTContext::GetBuiltinTypeByName(ConstString name) {
+CompilerType TypeSystemClang::GetBuiltinTypeByName(ConstString name) {
   return GetBasicType(GetBasicTypeEnumeration(name));
 }
 
 lldb::BasicType
-ClangASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) {
   if (type) {
     clang::QualType qual_type(GetQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     if (type_class == clang::Type::Builtin) {
       switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
       case clang::BuiltinType::Void:
         return eBasicTypeVoid;
       case clang::BuiltinType::Bool:
if (type_class == clang::Type::Builtin) {
       default:
         return eBasicTypeOther;
       }
     }
   }
   return eBasicTypeInvalid;
 }
 
-void ClangASTContext::ForEachEnumerator(
+void TypeSystemClang::ForEachEnumerator(
     lldb::opaque_compiler_type_t type,
     std::function<bool(const CompilerType &integer_type,
                        ConstString name,
                        const llvm::APSInt &value)> const &callback) {
   const clang::EnumType *enum_type =
       llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type));
   if (enum_type) {
     const clang::EnumDecl *enum_decl = enum_type->getDecl();
if (enum_decl) {
           break;
       }
     }
   }
 }
 
 #pragma mark Aggregate Types
 
-uint32_t ClangASTContext::GetNumFields(lldb::opaque_compiler_type_t type) {
+uint32_t TypeSystemClang::GetNumFields(lldb::opaque_compiler_type_t type) {
   if (!type)
     return 0;
 
   uint32_t count = 0;
   clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
if (idx < (class_interface_decl->ivar_size())) {
           return ivar_qual_type.getAsOpaquePtr();
         }
       }
     }
   }
   return nullptr;
 }
 
-CompilerType ClangASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
+CompilerType TypeSystemClang::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
                                               size_t idx, std::string &name,
                                               uint64_t *bit_offset_ptr,
                                               uint32_t *bitfield_bit_size_ptr,
                                               bool *is_bitfield_ptr) {
   if (!type)
     return CompilerType();
 
   clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
CompilerType TypeSystemClang::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
 
   default:
     break;
   }
   return CompilerType();
 }
 
 uint32_t
-ClangASTContext::GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) {
   uint32_t count = 0;
   clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
TypeSystemClang::GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) {
 
   default:
     break;
   }
   return count;
 }
 
 uint32_t
-ClangASTContext::GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) {
   uint32_t count = 0;
   clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
       if (cxx_record_decl)
         count = cxx_record_decl->getNumVBases();
     }
     break;
 
   default:
     break;
   }
   return count;
 }
 
-CompilerType ClangASTContext::GetDirectBaseClassAtIndex(
+CompilerType TypeSystemClang::GetDirectBaseClassAtIndex(
     lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) {
   clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
case clang::Type::ObjCInterface:
     break;
 
   default:
     break;
   }
   return CompilerType();
 }
 
-CompilerType ClangASTContext::GetVirtualBaseClassAtIndex(
+CompilerType TypeSystemClang::GetVirtualBaseClassAtIndex(
     lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) {
   clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
CompilerType TypeSystemClang::GetVirtualBaseClassAtIndex(
   return CompilerType();
 }
 
 // If a pointer to a pointee type (the clang_type arg) says that it has no
 // children, then we either need to trust it, or override it and return a
 // different result. For example, an "int *" has one child that is an integer,
 // but a function pointer doesn't have any children. Likewise if a Record type
 // claims it has no children, then there really is nothing to show.
-uint32_t ClangASTContext::GetNumPointeeChildren(clang::QualType type) {
+uint32_t TypeSystemClang::GetNumPointeeChildren(clang::QualType type) {
   if (type.isNull())
     return 0;
 
   clang::QualType qual_type = RemoveWrappingTypes(type.getCanonicalType());
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Builtin:
     switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
uint32_t TypeSystemClang::GetNumPointeeChildren(clang::QualType type) {
   case clang::Type::ObjCObjectPointer:
     return 1;
   default:
     break;
   }
   return 0;
 }
 
-CompilerType ClangASTContext::GetChildCompilerTypeAtIndex(
+CompilerType TypeSystemClang::GetChildCompilerTypeAtIndex(
     lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
     bool transparent_pointers, bool omit_empty_base_classes,
     bool ignore_array_bounds, std::string &child_name,
     uint32_t &child_byte_size, int32_t &child_byte_offset,
     uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
     bool &child_is_base_class, bool &child_is_deref_of_parent,
     ValueObject *valobj, uint64_t &language_flags) {
   if (!type)
if (idx_is_valid && GetCompleteType(type)) {
             base_class_end = cxx_record_decl->bases_end();
              base_class != base_class_end; ++base_class) {
           const clang::CXXRecordDecl *base_class_decl = nullptr;
 
           // Skip empty base classes
           if (omit_empty_base_classes) {
             base_class_decl = llvm::cast<clang::CXXRecordDecl>(
                 base_class->getType()->getAs<clang::RecordType>()->getDecl());
-            if (!ClangASTContext::RecordHasFields(base_class_decl))
+            if (!TypeSystemClang::RecordHasFields(base_class_decl))
               continue;
           }
 
           if (idx == child_idx) {
             if (base_class_decl == nullptr)
               base_class_decl = llvm::cast<clang::CXXRecordDecl>(
                   base_class->getType()->getAs<clang::RecordType>()->getDecl());
 
static uint32_t GetIndexForRecordBase(const clang::RecordDecl *record_decl,
   }
 
   return UINT32_MAX;
 }
 
 static uint32_t GetIndexForRecordChild(const clang::RecordDecl *record_decl,
                                        clang::NamedDecl *canonical_decl,
                                        bool omit_empty_base_classes) {
-  uint32_t child_idx = ClangASTContext::GetNumBaseClasses(
+  uint32_t child_idx = TypeSystemClang::GetNumBaseClasses(
       llvm::dyn_cast<clang::CXXRecordDecl>(record_decl),
       omit_empty_base_classes);
 
   clang::RecordDecl::field_iterator field, field_end;
   for (field = record_decl->field_begin(), field_end = record_decl->field_end();
        field != field_end; ++field, ++child_idx) {
     if (field->getCanonicalDecl() == canonical_decl)
       return child_idx;

 // with: { 1,  1 } The first index 1 is the child index for "class A" within
 // class C The second index 1 is the child index for "m_b" within class A
 //
 // With omit_empty_base_classes == true we would get an integer array back
 // with: { 0,  1 } The first index 0 is the child index for "class A" within
 // class C (since class B doesn't have any members it doesn't count) The second
 // index 1 is the child index for "m_b" within class A
 
-size_t ClangASTContext::GetIndexOfChildMemberWithName(
+size_t TypeSystemClang::GetIndexOfChildMemberWithName(
     lldb::opaque_compiler_type_t type, const char *name,
     bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) {
   if (type && name && name[0]) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::Record:
       if (GetCompleteType(type)) {
case clang::Type::Record:
             if (field_type.GetIndexOfChildMemberWithName(
                     name, omit_empty_base_classes, child_indexes))
               return child_indexes.size();
             child_indexes.pop_back();
 
           } else if (field_name.equals(name_sref)) {
             // We have to add on the number of base classes to this index!
             child_indexes.push_back(
-                child_idx + ClangASTContext::GetNumBaseClasses(
+                child_idx + TypeSystemClang::GetNumBaseClasses(
                                 cxx_record_decl, omit_empty_base_classes));
             return child_indexes.size();
           }
         }
 
         if (cxx_record_decl) {
           const clang::RecordDecl *parent_record_decl = cxx_record_decl;
 
if (type && name && name[0]) {
 
     //        case clang::Type::MemberPointerType:
     //            {
     //                MemberPointerType *mem_ptr_type =
     //                llvm::cast<MemberPointerType>(qual_type.getTypePtr());
     //                clang::QualType pointee_type =
     //                mem_ptr_type->getPointeeType();
     //
-    //                if (ClangASTContext::IsAggregateType
+    //                if (TypeSystemClang::IsAggregateType
     //                (pointee_type.getAsOpaquePtr()))
     //                {
     //                    return GetIndexOfChildWithName (ast,
     //                                                    mem_ptr_type->getPointeeType().getAsOpaquePtr(),
     //                                                    name);
     //                }
     //            }
     //            break;
size_t TypeSystemClang::GetIndexOfChildMemberWithName(
   return 0;
 }
 
 // Get the index of the child of "clang_type" whose name matches. This function
 // doesn't descend into the children, but only looks one level deep and name
 // matches can include base class names.
 
 uint32_t
-ClangASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
+TypeSystemClang::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
                                          const char *name,
                                          bool omit_empty_base_classes) {
   if (type && name && name[0]) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
 
     switch (type_class) {
case clang::Type::Record:
                base_class != base_class_end; ++base_class) {
             // Skip empty base classes
             clang::CXXRecordDecl *base_class_decl =
                 llvm::cast<clang::CXXRecordDecl>(
                     base_class->getType()
                         ->getAs<clang::RecordType>()
                         ->getDecl());
             if (omit_empty_base_classes &&
-                !ClangASTContext::RecordHasFields(base_class_decl))
+                !TypeSystemClang::RecordHasFields(base_class_decl))
               continue;
 
             CompilerType base_class_clang_type = GetType(base_class->getType());
             std::string base_class_type_name(
                 base_class_clang_type.GetTypeName().AsCString(""));
             if (base_class_type_name == name)
               return child_idx;
             ++child_idx;
if (type && name && name[0]) {
 
     //        case clang::Type::MemberPointerType:
     //            {
     //                MemberPointerType *mem_ptr_type =
     //                llvm::cast<MemberPointerType>(qual_type.getTypePtr());
     //                clang::QualType pointee_type =
     //                mem_ptr_type->getPointeeType();
     //
-    //                if (ClangASTContext::IsAggregateType
+    //                if (TypeSystemClang::IsAggregateType
     //                (pointee_type.getAsOpaquePtr()))
     //                {
     //                    return GetIndexOfChildWithName (ast,
     //                                                    mem_ptr_type->getPointeeType().getAsOpaquePtr(),
     //                                                    name);
     //                }
     //            }
     //            break;
if (type && name && name[0]) {
     default:
       break;
     }
   }
   return UINT32_MAX;
 }
 
 size_t
-ClangASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) {
   if (!type)
     return 0;
 
   clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
TypeSystemClang::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) {
   default:
     break;
   }
 
   return 0;
 }
 
 const clang::ClassTemplateSpecializationDecl *
-ClangASTContext::GetAsTemplateSpecialization(
+TypeSystemClang::GetAsTemplateSpecialization(
     lldb::opaque_compiler_type_t type) {
   if (!type)
     return nullptr;
 
   clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record: {
     if (! GetCompleteType(type))
       return nullptr;
     const clang::CXXRecordDecl *cxx_record_decl =
         qual_type->getAsCXXRecordDecl();
     if (!cxx_record_decl)
       return nullptr;
     return llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(
         cxx_record_decl);
   }
 
   default:
     return nullptr;
   }
 }
 
 lldb::TemplateArgumentKind
-ClangASTContext::GetTemplateArgumentKind(lldb::opaque_compiler_type_t type,
+TypeSystemClang::GetTemplateArgumentKind(lldb::opaque_compiler_type_t type,
                                          size_t arg_idx) {
   const clang::ClassTemplateSpecializationDecl *template_decl =
       GetAsTemplateSpecialization(type);
   if (! template_decl || arg_idx >= template_decl->getTemplateArgs().size())
     return eTemplateArgumentKindNull;
 
   switch (template_decl->getTemplateArgs()[arg_idx].getKind()) {
   case clang::TemplateArgument::Null:
TypeSystemClang::GetTemplateArgumentKind(lldb::opaque_compiler_type_t type,
 
   case clang::TemplateArgument::Pack:
     return eTemplateArgumentKindPack;
   }
   llvm_unreachable("Unhandled clang::TemplateArgument::ArgKind");
 }
 
 CompilerType
-ClangASTContext::GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
+TypeSystemClang::GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
                                          size_t idx) {
   const clang::ClassTemplateSpecializationDecl *template_decl =
       GetAsTemplateSpecialization(type);
   if (!template_decl || idx >= template_decl->getTemplateArgs().size())
     return CompilerType();
 
   const clang::TemplateArgument &template_arg =
       template_decl->getTemplateArgs()[idx];
   if (template_arg.getKind() != clang::TemplateArgument::Type)
     return CompilerType();
 
   return GetType(template_arg.getAsType());
 }
 
 Optional<CompilerType::IntegralTemplateArgument>
-ClangASTContext::GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type,
+TypeSystemClang::GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type,
                                              size_t idx) {
   const clang::ClassTemplateSpecializationDecl *template_decl =
       GetAsTemplateSpecialization(type);
   if (! template_decl || idx >= template_decl->getTemplateArgs().size())
     return llvm::None;
 
   const clang::TemplateArgument &template_arg =
       template_decl->getTemplateArgs()[idx];
   if (template_arg.getKind() != clang::TemplateArgument::Integral)
     return llvm::None;
 
   return {
       {template_arg.getAsIntegral(), GetType(template_arg.getIntegralType())}};
 }
 
-CompilerType ClangASTContext::GetTypeForFormatters(void *type) {
+CompilerType TypeSystemClang::GetTypeForFormatters(void *type) {
   if (type)
     return ClangUtil::RemoveFastQualifiers(CompilerType(this, type));
   return CompilerType();
 }
 
-clang::EnumDecl *ClangASTContext::GetAsEnumDecl(const CompilerType &type) {
+clang::EnumDecl *TypeSystemClang::GetAsEnumDecl(const CompilerType &type) {
   const clang::EnumType *enutype =
       llvm::dyn_cast<clang::EnumType>(ClangUtil::GetCanonicalQualType(type));
   if (enutype)
     return enutype->getDecl();
   return nullptr;
 }
 
-clang::RecordDecl *ClangASTContext::GetAsRecordDecl(const CompilerType &type) {
+clang::RecordDecl *TypeSystemClang::GetAsRecordDecl(const CompilerType &type) {
   const clang::RecordType *record_type =
       llvm::dyn_cast<clang::RecordType>(ClangUtil::GetCanonicalQualType(type));
   if (record_type)
     return record_type->getDecl();
   return nullptr;
 }
 
-clang::TagDecl *ClangASTContext::GetAsTagDecl(const CompilerType &type) {
+clang::TagDecl *TypeSystemClang::GetAsTagDecl(const CompilerType &type) {
   return ClangUtil::GetAsTagDecl(type);
 }
 
 clang::TypedefNameDecl *
-ClangASTContext::GetAsTypedefDecl(const CompilerType &type) {
+TypeSystemClang::GetAsTypedefDecl(const CompilerType &type) {
   const clang::TypedefType *typedef_type =
       llvm::dyn_cast<clang::TypedefType>(ClangUtil::GetQualType(type));
   if (typedef_type)
     return typedef_type->getDecl();
   return nullptr;
 }
 
 clang::CXXRecordDecl *
-ClangASTContext::GetAsCXXRecordDecl(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetAsCXXRecordDecl(lldb::opaque_compiler_type_t type) {
   return GetCanonicalQualType(type)->getAsCXXRecordDecl();
 }
 
 clang::ObjCInterfaceDecl *
-ClangASTContext::GetAsObjCInterfaceDecl(const CompilerType &type) {
+TypeSystemClang::GetAsObjCInterfaceDecl(const CompilerType &type) {
   const clang::ObjCObjectType *objc_class_type =
       llvm::dyn_cast<clang::ObjCObjectType>(
           ClangUtil::GetCanonicalQualType(type));
   if (objc_class_type)
     return objc_class_type->getInterface();
   return nullptr;
 }
 
-clang::FieldDecl *ClangASTContext::AddFieldToRecordType(
+clang::FieldDecl *TypeSystemClang::AddFieldToRecordType(
     const CompilerType &type, llvm::StringRef name,
     const CompilerType &field_clang_type, AccessType access,
     uint32_t bitfield_bit_size) {
   if (!type.IsValid() || !field_clang_type.IsValid())
     return nullptr;
-  ClangASTContext *ast =
-      llvm::dyn_cast_or_null<ClangASTContext>(type.GetTypeSystem());
+  TypeSystemClang *ast =
+      llvm::dyn_cast_or_null<TypeSystemClang>(type.GetTypeSystem());
   if (!ast)
     return nullptr;
   clang::ASTContext &clang_ast = ast->getASTContext();
   clang::IdentifierInfo *ident = nullptr;
   if (!name.empty())
     ident = &clang_ast.Idents.get(name);
 
   clang::FieldDecl *field = nullptr;
if (name.empty()) {
             Rec->setAnonymousStructOrUnion(true);
             field->setImplicit();
           }
       }
     }
 
     if (field) {
       field->setAccess(
-          ClangASTContext::ConvertAccessTypeToAccessSpecifier(access));
+          TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access));
 
       record_decl->addDecl(field);
 
 #ifdef LLDB_CONFIGURATION_DEBUG
       VerifyDecl(field);
 #endif
     }
   } else {
#ifdef LLDB_CONFIGURATION_DEBUG
         VerifyDecl(field);
 #endif
       }
     }
   }
   return field;
 }
 
-void ClangASTContext::BuildIndirectFields(const CompilerType &type) {
+void TypeSystemClang::BuildIndirectFields(const CompilerType &type) {
   if (!type)
     return;
 
-  ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
+  TypeSystemClang *ast = llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
   if (!ast)
     return;
 
   clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type);
 
   if (!record_decl)
     return;
 
if (field_pos->isAnonymousStructOrUnion()) {
           clang::IndirectFieldDecl *indirect_field =
               clang::IndirectFieldDecl::Create(
                   ast->getASTContext(), record_decl, clang::SourceLocation(),
                   nested_field_decl->getIdentifier(),
                   nested_field_decl->getType(), {chain, 2});
 
           indirect_field->setImplicit();
 
-          indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(
+          indirect_field->setAccess(TypeSystemClang::UnifyAccessSpecifiers(
               field_pos->getAccess(), nested_field_decl->getAccess()));
 
           indirect_fields.push_back(indirect_field);
         } else if (clang::IndirectFieldDecl *nested_indirect_field_decl =
                        llvm::dyn_cast<clang::IndirectFieldDecl>(*di)) {
           size_t nested_chain_size =
               nested_indirect_field_decl->getChainingSize();
           clang::NamedDecl **chain = new (ast->getASTContext())
if (field_pos->isAnonymousStructOrUnion()) {
               clang::IndirectFieldDecl::Create(
                   ast->getASTContext(), record_decl, clang::SourceLocation(),
                   nested_indirect_field_decl->getIdentifier(),
                   nested_indirect_field_decl->getType(),
                   {chain, nested_chain_size + 1});
 
           indirect_field->setImplicit();
 
-          indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(
+          indirect_field->setAccess(TypeSystemClang::UnifyAccessSpecifiers(
               field_pos->getAccess(), nested_indirect_field_decl->getAccess()));
 
           indirect_fields.push_back(indirect_field);
         }
       }
     }
   }
 
   // Check the last field to see if it has an incomplete array type as its last
   // member and if it does, the tell the record decl about it
   if (last_field_pos != field_end_pos) {
     if (last_field_pos->getType()->isIncompleteArrayType())
       record_decl->hasFlexibleArrayMember();
   }
 
   for (IndirectFieldVector::iterator ifi = indirect_fields.begin(),
                                      ife = indirect_fields.end();
        ifi < ife; ++ifi) {
     record_decl->addDecl(*ifi);
   }
 }
 
-void ClangASTContext::SetIsPacked(const CompilerType &type) {
+void TypeSystemClang::SetIsPacked(const CompilerType &type) {
   if (type) {
-    ClangASTContext *ast =
-        llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
+    TypeSystemClang *ast =
+        llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
     if (ast) {
       clang::RecordDecl *record_decl = GetAsRecordDecl(type);
 
       if (!record_decl)
         return;
 
       record_decl->addAttr(
           clang::PackedAttr::CreateImplicit(ast->getASTContext()));
     }
   }
 }
 
-clang::VarDecl *ClangASTContext::AddVariableToRecordType(
+clang::VarDecl *TypeSystemClang::AddVariableToRecordType(
     const CompilerType &type, llvm::StringRef name,
     const CompilerType &var_type, AccessType access) {
   if (!type.IsValid() || !var_type.IsValid())
     return nullptr;
 
-  ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
+  TypeSystemClang *ast = llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
   if (!ast)
     return nullptr;
 
   clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type);
   if (!record_decl)
     return nullptr;
 
   clang::VarDecl *var_decl = nullptr;
var_decl = clang::VarDecl::Create(
       ident,                            // clang::IdentifierInfo *
       ClangUtil::GetQualType(var_type), // Variable clang::QualType
       nullptr,                          // TypeSourceInfo *
       clang::SC_Static);                // StorageClass
   if (!var_decl)
     return nullptr;
 
   var_decl->setAccess(
-      ClangASTContext::ConvertAccessTypeToAccessSpecifier(access));
+      TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access));
   record_decl->addDecl(var_decl);
 
 #ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(var_decl);
 #endif
 
   return var_decl;
 }
 
-clang::CXXMethodDecl *ClangASTContext::AddMethodToCXXRecordType(
+clang::CXXMethodDecl *TypeSystemClang::AddMethodToCXXRecordType(
     lldb::opaque_compiler_type_t type, llvm::StringRef name,
     const char *mangled_name, const CompilerType &method_clang_type,
     lldb::AccessType access, bool is_virtual, bool is_static, bool is_inline,
     bool is_explicit, bool is_attr_used, bool is_artificial) {
   if (!type || !method_clang_type.IsValid() || name.empty())
     return nullptr;
 
   clang::QualType record_qual_type(GetCanonicalQualType(type));
if (name.startswith("~")) {
 
     if (IsOperator(name, op_kind)) {
       if (op_kind != clang::NUM_OVERLOADED_OPERATORS) {
         // Check the number of operator parameters. Sometimes we have seen bad
         // DWARF that doesn't correctly describe operators and if we try to
         // create a method and add it to the class, clang will assert and
         // crash, so we need to make sure things are acceptable.
         const bool is_method = true;
-        if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount(
+        if (!TypeSystemClang::CheckOverloadedOperatorKindParameterCount(
                 is_method, op_kind, num_params))
           return nullptr;
         cxx_method_decl = clang::CXXMethodDecl::Create(
             getASTContext(), cxx_record_decl, clang::SourceLocation(),
             clang::DeclarationNameInfo(
                 getASTContext().DeclarationNames.getCXXOperatorName(op_kind),
                 clang::SourceLocation()),
             method_qual_type,
if (cxx_method_decl == nullptr) {
           clang::DeclarationNameInfo(decl_name, clang::SourceLocation()),
           method_qual_type,
           nullptr, // TypeSourceInfo *
           SC, is_inline, CSK_unspecified, clang::SourceLocation());
     }
   }
 
   clang::AccessSpecifier access_specifier =
-      ClangASTContext::ConvertAccessTypeToAccessSpecifier(access);
+      TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access);
 
   cxx_method_decl->setAccess(access_specifier);
   cxx_method_decl->setVirtualAsWritten(is_virtual);
 
   if (is_attr_used)
     cxx_method_decl->addAttr(clang::UsedAttr::CreateImplicit(getASTContext()));
 
   if (mangled_name != nullptr) {

 
 #ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(cxx_method_decl);
 #endif
 
   return cxx_method_decl;
 }
 
-void ClangASTContext::AddMethodOverridesForCXXRecordType(
+void TypeSystemClang::AddMethodOverridesForCXXRecordType(
     lldb::opaque_compiler_type_t type) {
   if (auto *record = GetAsCXXRecordDecl(type))
     for (auto *method : record->methods())
       addOverridesForMethod(method);
 }
 
 #pragma mark C++ Base Classes
 
 std::unique_ptr<clang::CXXBaseSpecifier>
-ClangASTContext::CreateBaseClassSpecifier(lldb::opaque_compiler_type_t type,
+TypeSystemClang::CreateBaseClassSpecifier(lldb::opaque_compiler_type_t type,
                                           AccessType access, bool is_virtual,
                                           bool base_of_class) {
   if (!type)
     return nullptr;
 
   return std::make_unique<clang::CXXBaseSpecifier>(
       clang::SourceRange(), is_virtual, base_of_class,
-      ClangASTContext::ConvertAccessTypeToAccessSpecifier(access),
+      TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access),
       getASTContext().getTrivialTypeSourceInfo(GetQualType(type)),
       clang::SourceLocation());
 }
 
-bool ClangASTContext::TransferBaseClasses(
+bool TypeSystemClang::TransferBaseClasses(
     lldb::opaque_compiler_type_t type,
     std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases) {
   if (!type)
     return false;
   clang::CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl(type);
   if (!cxx_record_decl)
     return false;
   std::vector<clang::CXXBaseSpecifier *> raw_bases;
   raw_bases.reserve(bases.size());
 
   // Clang will make a copy of them, so it's ok that we pass pointers that we're
   // about to destroy.
   for (auto &b : bases)
     raw_bases.push_back(b.get());
   cxx_record_decl->setBases(raw_bases.data(), raw_bases.size());
   return true;
 }
 
-bool ClangASTContext::SetObjCSuperClass(
+bool TypeSystemClang::SetObjCSuperClass(
     const CompilerType &type, const CompilerType &superclass_clang_type) {
-  ClangASTContext *ast =
-      llvm::dyn_cast_or_null<ClangASTContext>(type.GetTypeSystem());
+  TypeSystemClang *ast =
+      llvm::dyn_cast_or_null<TypeSystemClang>(type.GetTypeSystem());
   if (!ast)
     return false;
   clang::ASTContext &clang_ast = ast->getASTContext();
 
   if (type && superclass_clang_type.IsValid() &&
       superclass_clang_type.GetTypeSystem() == type.GetTypeSystem()) {
     clang::ObjCInterfaceDecl *class_interface_decl =
         GetAsObjCInterfaceDecl(type);
     clang::ObjCInterfaceDecl *super_interface_decl =
         GetAsObjCInterfaceDecl(superclass_clang_type);
     if (class_interface_decl && super_interface_decl) {
       class_interface_decl->setSuperClass(clang_ast.getTrivialTypeSourceInfo(
           clang_ast.getObjCInterfaceType(super_interface_decl)));
       return true;
     }
   }
   return false;
 }
 
-bool ClangASTContext::AddObjCClassProperty(
+bool TypeSystemClang::AddObjCClassProperty(
     const CompilerType &type, const char *property_name,
     const CompilerType &property_clang_type, clang::ObjCIvarDecl *ivar_decl,
     const char *property_setter_name, const char *property_getter_name,
     uint32_t property_attributes, ClangASTMetadata *metadata) {
   if (!type || !property_clang_type.IsValid() || property_name == nullptr ||
       property_name[0] == '\0')
     return false;
-  ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
+  TypeSystemClang *ast = llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
   if (!ast)
     return false;
   clang::ASTContext &clang_ast = ast->getASTContext();
 
   clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type);
   if (!class_interface_decl)
     return false;
 
bool TypeSystemClang::AddObjCClassProperty(
   if (setter) {
     setter->setPropertyAccessor(true);
     property_decl->setSetterMethodDecl(setter);
   }
 
   return true;
 }
 
-bool ClangASTContext::IsObjCClassTypeAndHasIVars(const CompilerType &type,
+bool TypeSystemClang::IsObjCClassTypeAndHasIVars(const CompilerType &type,
                                                  bool check_superclass) {
   clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type);
   if (class_interface_decl)
     return ObjCDeclHasIVars(class_interface_decl, check_superclass);
   return false;
 }
 
-clang::ObjCMethodDecl *ClangASTContext::AddMethodToObjCObjectType(
+clang::ObjCMethodDecl *TypeSystemClang::AddMethodToObjCObjectType(
     const CompilerType &type,
     const char *name, // the full symbol name as seen in the symbol table
                       // (lldb::opaque_compiler_type_t type, "-[NString
                       // stringWithCString:]")
     const CompilerType &method_clang_type, lldb::AccessType access,
     bool is_artificial, bool is_variadic, bool is_objc_direct_call) {
   if (!type || !method_clang_type.IsValid())
     return nullptr;
 
   clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type);
 
   if (class_interface_decl == nullptr)
     return nullptr;
-  ClangASTContext *lldb_ast =
-      llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
+  TypeSystemClang *lldb_ast =
+      llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
   if (lldb_ast == nullptr)
     return nullptr;
   clang::ASTContext &ast = lldb_ast->getASTContext();
 
   const char *selector_start = ::strchr(name, ' ');
   if (selector_start == nullptr)
     return nullptr;
 

 
 #ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(objc_method_decl);
 #endif
 
   return objc_method_decl;
 }
 
-bool ClangASTContext::SetHasExternalStorage(lldb::opaque_compiler_type_t type,
+bool TypeSystemClang::SetHasExternalStorage(lldb::opaque_compiler_type_t type,
                                             bool has_extern) {
   if (!type)
     return false;
 
   clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
 
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
bool TypeSystemClang::SetHasExternalStorage(lldb::opaque_compiler_type_t type,
   default:
     break;
   }
   return false;
 }
 
 #pragma mark TagDecl
 
-bool ClangASTContext::StartTagDeclarationDefinition(const CompilerType &type) {
+bool TypeSystemClang::StartTagDeclarationDefinition(const CompilerType &type) {
   clang::QualType qual_type(ClangUtil::GetQualType(type));
   if (!qual_type.isNull()) {
     const clang::TagType *tag_type = qual_type->getAs<clang::TagType>();
     if (tag_type) {
       clang::TagDecl *tag_decl = tag_type->getDecl();
       if (tag_decl) {
         tag_decl->startDefinition();
         return true;
       }
     }
 
     const clang::ObjCObjectType *object_type =
         qual_type->getAs<clang::ObjCObjectType>();
     if (object_type) {
       clang::ObjCInterfaceDecl *interface_decl = object_type->getInterface();
       if (interface_decl) {
         interface_decl->startDefinition();
         return true;
       }
     }
   }
   return false;
 }
 
-bool ClangASTContext::CompleteTagDeclarationDefinition(
+bool TypeSystemClang::CompleteTagDeclarationDefinition(
     const CompilerType &type) {
   clang::QualType qual_type(ClangUtil::GetQualType(type));
   if (qual_type.isNull())
     return false;
 
   // Make sure we use the same methodology as
-  // ClangASTContext::StartTagDeclarationDefinition() as to how we start/end
+  // TypeSystemClang::StartTagDeclarationDefinition() as to how we start/end
   // the definition.
   const clang::TagType *tag_type = qual_type->getAs<clang::TagType>();
   if (tag_type) {
     clang::TagDecl *tag_decl = tag_type->getDecl();
 
     if (auto *cxx_record_decl = llvm::dyn_cast<CXXRecordDecl>(tag_decl)) {
       // If we have a move constructor declared but no copy constructor we
       // need to explicitly mark it as deleted. Usually Sema would do this for
bool TypeSystemClang::CompleteTagDeclarationDefinition(
 
   if (!enutype)
     return false;
   clang::EnumDecl *enum_decl = enutype->getDecl();
 
   if (enum_decl->isCompleteDefinition())
     return true;
 
-  ClangASTContext *lldb_ast =
-      llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
+  TypeSystemClang *lldb_ast =
+      llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
   if (lldb_ast == nullptr)
     return false;
   clang::ASTContext &ast = lldb_ast->getASTContext();
 
   /// TODO This really needs to be fixed.
 
   QualType integer_type(enum_decl->getIntegerType());
   if (!integer_type.isNull()) {
if (!integer_type.isNull()) {
 
     enum_decl->completeDefinition(enum_decl->getIntegerType(),
                                   promotion_qual_type, NumPositiveBits,
                                   NumNegativeBits);
   }
   return true;
 }
 
-clang::EnumConstantDecl *ClangASTContext::AddEnumerationValueToEnumerationType(
+clang::EnumConstantDecl *TypeSystemClang::AddEnumerationValueToEnumerationType(
     const CompilerType &enum_type, const Declaration &decl, const char *name,
     const llvm::APSInt &value) {
 
   if (!enum_type || ConstString(name).IsEmpty())
     return nullptr;
 
   lldbassert(enum_type.GetTypeSystem() == static_cast<TypeSystem *>(this));
 

 
 #ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(enumerator_decl);
 #endif
 
   return enumerator_decl;
 }
 
-clang::EnumConstantDecl *ClangASTContext::AddEnumerationValueToEnumerationType(
+clang::EnumConstantDecl *TypeSystemClang::AddEnumerationValueToEnumerationType(
     const CompilerType &enum_type, const Declaration &decl, const char *name,
     int64_t enum_value, uint32_t enum_value_bit_size) {
   CompilerType underlying_type =
       GetEnumerationIntegerType(enum_type.GetOpaqueQualType());
   bool is_signed = false;
   underlying_type.IsIntegerType(is_signed);
 
   llvm::APSInt value(enum_value_bit_size, is_signed);
   value = enum_value;
 
   return AddEnumerationValueToEnumerationType(enum_type, decl, name, value);
 }
 
 CompilerType
-ClangASTContext::GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) {
+TypeSystemClang::GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) {
   clang::QualType enum_qual_type(GetCanonicalQualType(type));
   const clang::Type *clang_type = enum_qual_type.getTypePtr();
   if (clang_type) {
     const clang::EnumType *enutype =
         llvm::dyn_cast<clang::EnumType>(clang_type);
     if (enutype) {
       clang::EnumDecl *enum_decl = enutype->getDecl();
       if (enum_decl)
         return GetType(enum_decl->getIntegerType());
     }
   }
   return CompilerType();
 }
 
 CompilerType
-ClangASTContext::CreateMemberPointerType(const CompilerType &type,
+TypeSystemClang::CreateMemberPointerType(const CompilerType &type,
                                          const CompilerType &pointee_type) {
   if (type && pointee_type.IsValid() &&
       type.GetTypeSystem() == pointee_type.GetTypeSystem()) {
-    ClangASTContext *ast =
-        llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
+    TypeSystemClang *ast =
+        llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
     if (!ast)
       return CompilerType();
     return ast->GetType(ast->getASTContext().getMemberPointerType(
         ClangUtil::GetQualType(pointee_type),
         ClangUtil::GetQualType(type).getTypePtr()));
   }
   return CompilerType();
 }
 
 // Dumping types
 #define DEPTH_INCREMENT 2
 
 #ifndef NDEBUG
 LLVM_DUMP_METHOD void
-ClangASTContext::dump(lldb::opaque_compiler_type_t type) const {
+TypeSystemClang::dump(lldb::opaque_compiler_type_t type) const {
   if (!type)
     return;
   clang::QualType qual_type(GetQualType(type));
   qual_type.dump();
 }
 #endif
 
-void ClangASTContext::Dump(Stream &s) {
+void TypeSystemClang::Dump(Stream &s) {
   Decl *tu = Decl::castFromDeclContext(GetTranslationUnitDecl());
   tu->dump(s.AsRawOstream());
 }
 
-void ClangASTContext::DumpFromSymbolFile(Stream &s,
+void TypeSystemClang::DumpFromSymbolFile(Stream &s,
                                          llvm::StringRef symbol_name) {
   SymbolFile *symfile = GetSymbolFile();
 
   if (!symfile)
     return;
 
   lldb_private::TypeList type_list;
   symfile->GetTypes(nullptr, eTypeClassAny, type_list);
if (auto *objc_obj = llvm::dyn_cast<clang::ObjCObjectType>(
         interface_decl->dump(s.AsRawOstream());
         continue;
       }
     }
     GetCanonicalQualType(full_type.GetOpaqueQualType()).dump(s.AsRawOstream());
   }
 }
 
-void ClangASTContext::DumpValue(
+void TypeSystemClang::DumpValue(
     lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s,
     lldb::Format format, const lldb_private::DataExtractor &data,
     lldb::offset_t data_byte_offset, size_t data_byte_size,
     uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types,
     bool show_summary, bool verbose, uint32_t depth) {
   if (!type)
     return;
 
if (GetCompleteType(type)) {
         for (base_class = cxx_record_decl->bases_begin(),
             base_class_end = cxx_record_decl->bases_end();
              base_class != base_class_end; ++base_class) {
           const clang::CXXRecordDecl *base_class_decl =
               llvm::cast<clang::CXXRecordDecl>(
                   base_class->getType()->getAs<clang::RecordType>()->getDecl());
 
           // Skip empty base classes
-          if (!verbose && !ClangASTContext::RecordHasFields(base_class_decl))
+          if (!verbose && !TypeSystemClang::RecordHasFields(base_class_decl))
             continue;
 
           if (base_class->isVirtual())
             field_bit_offset =
                 record_layout.getVBaseClassOffset(base_class_decl)
                     .getQuantity() *
                 8;
           else
static bool DumpEnumValue(const clang::QualType &qual_type, Stream *s,
 
   // If there is a remainder that is not covered by the value, print it as hex.
   if (remaining_value)
     s->Printf("0x%" PRIx64, remaining_value);
 
   return true;
 }
 
-bool ClangASTContext::DumpTypeValue(
+bool TypeSystemClang::DumpTypeValue(
     lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format,
     const lldb_private::DataExtractor &data, lldb::offset_t byte_offset,
     size_t byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
     ExecutionContextScope *exe_scope) {
   if (!type)
     return false;
   if (IsAggregateType(type)) {
     return false;
default:
                                  exe_scope);
       }
       break;
     }
   }
   return false;
 }
 
-void ClangASTContext::DumpSummary(lldb::opaque_compiler_type_t type,
+void TypeSystemClang::DumpSummary(lldb::opaque_compiler_type_t type,
                                   ExecutionContext *exe_ctx, Stream *s,
                                   const lldb_private::DataExtractor &data,
                                   lldb::offset_t data_byte_offset,
                                   size_t data_byte_size) {
   uint32_t length = 0;
   if (IsCStringType(type, length)) {
     if (exe_ctx) {
       Process *process = exe_ctx->GetProcessPtr();
if (exe_ctx) {
         }
         if (total_cstr_len > 0)
           s->PutChar('"');
       }
     }
   }
 }
 
-void ClangASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type) {
+void TypeSystemClang::DumpTypeDescription(lldb::opaque_compiler_type_t type) {
   StreamFile s(stdout, false);
   DumpTypeDescription(type, &s);
 
   CompilerType ct(this, type);
   const clang::Type *clang_type = ClangUtil::GetQualType(ct).getTypePtr();
   ClangASTMetadata *metadata = GetMetadata(clang_type);
   if (metadata) {
     metadata->Dump(&s);
   }
 }
 
-void ClangASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type,
+void TypeSystemClang::DumpTypeDescription(lldb::opaque_compiler_type_t type,
                                           Stream *s) {
   if (type) {
     clang::QualType qual_type =
         RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef});
 
     llvm::SmallVector<char, 1024> buf;
     llvm::raw_svector_ostream llvm_ostrm(buf);
 
if (type) {
     }
 
     if (buf.size() > 0) {
       s->Write(buf.data(), buf.size());
     }
   }
 }
 
-void ClangASTContext::DumpTypeName(const CompilerType &type) {
+void TypeSystemClang::DumpTypeName(const CompilerType &type) {
   if (ClangUtil::IsClangType(type)) {
     clang::QualType qual_type(
         ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type)));
 
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::Record: {
       const clang::CXXRecordDecl *cxx_record_decl =
if (ClangUtil::IsClangType(type)) {
 
     case clang::Type::Paren:
       printf("paren ");
       return DumpTypeName(CompilerType(
           type.GetTypeSystem(),
           llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()));
 
     default:
-      printf("ClangASTContext::DumpTypeName() type_class = %u", type_class);
+      printf("TypeSystemClang::DumpTypeName() type_class = %u", type_class);
       break;
     }
   }
 }
 
-clang::ClassTemplateDecl *ClangASTContext::ParseClassTemplateDecl(
+clang::ClassTemplateDecl *TypeSystemClang::ParseClassTemplateDecl(
     clang::DeclContext *decl_ctx, lldb::AccessType access_type,
     const char *parent_name, int tag_decl_kind,
-    const ClangASTContext::TemplateParameterInfos &template_param_infos) {
+    const TypeSystemClang::TemplateParameterInfos &template_param_infos) {
   if (template_param_infos.IsValid()) {
     std::string template_basename(parent_name);
     template_basename.erase(template_basename.find('<'));
 
     return CreateClassTemplateDecl(decl_ctx, access_type,
                                    template_basename.c_str(), tag_decl_kind,
                                    template_param_infos);
   }
   return nullptr;
 }
 
-void ClangASTContext::CompleteTagDecl(clang::TagDecl *decl) {
+void TypeSystemClang::CompleteTagDecl(clang::TagDecl *decl) {
   SymbolFile *sym_file = GetSymbolFile();
   if (sym_file) {
     CompilerType clang_type = GetTypeForDecl(decl);
     if (clang_type)
       sym_file->CompleteType(clang_type);
   }
 }
 
-void ClangASTContext::CompleteObjCInterfaceDecl(
+void TypeSystemClang::CompleteObjCInterfaceDecl(
     clang::ObjCInterfaceDecl *decl) {
   SymbolFile *sym_file = GetSymbolFile();
   if (sym_file) {
     CompilerType clang_type = GetTypeForDecl(decl);
     if (clang_type)
       sym_file->CompleteType(clang_type);
   }
 }
 
-DWARFASTParser *ClangASTContext::GetDWARFParser() {
+DWARFASTParser *TypeSystemClang::GetDWARFParser() {
   if (!m_dwarf_ast_parser_up)
     m_dwarf_ast_parser_up.reset(new DWARFASTParserClang(*this));
   return m_dwarf_ast_parser_up.get();
 }
 
-PDBASTParser *ClangASTContext::GetPDBParser() {
+PDBASTParser *TypeSystemClang::GetPDBParser() {
   if (!m_pdb_ast_parser_up)
     m_pdb_ast_parser_up.reset(new PDBASTParser(*this));
   return m_pdb_ast_parser_up.get();
 }
 
-bool ClangASTContext::LayoutRecordType(
+bool TypeSystemClang::LayoutRecordType(
     const clang::RecordDecl *record_decl, uint64_t &bit_size,
     uint64_t &alignment,
     llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
         &base_offsets,
     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
         &vbase_offsets) {
   lldb_private::ClangASTImporter *importer = nullptr;
   if (m_dwarf_ast_parser_up)
     importer = &m_dwarf_ast_parser_up->GetClangASTImporter();
   if (!importer && m_pdb_ast_parser_up)
     importer = &m_pdb_ast_parser_up->GetClangASTImporter();
   if (!importer)
     return false;
 
   return importer->LayoutRecordType(record_decl, bit_size, alignment,
                                     field_offsets, base_offsets, vbase_offsets);
 }
 
 // CompilerDecl override functions
 
-ConstString ClangASTContext::DeclGetName(void *opaque_decl) {
+ConstString TypeSystemClang::DeclGetName(void *opaque_decl) {
   if (opaque_decl) {
     clang::NamedDecl *nd =
         llvm::dyn_cast<NamedDecl>((clang::Decl *)opaque_decl);
     if (nd != nullptr)
       return ConstString(nd->getDeclName().getAsString());
   }
   return ConstString();
 }
 
-ConstString ClangASTContext::DeclGetMangledName(void *opaque_decl) {
+ConstString TypeSystemClang::DeclGetMangledName(void *opaque_decl) {
   if (opaque_decl) {
     clang::NamedDecl *nd =
         llvm::dyn_cast<clang::NamedDecl>((clang::Decl *)opaque_decl);
     if (nd != nullptr && !llvm::isa<clang::ObjCMethodDecl>(nd)) {
       clang::MangleContext *mc = getMangleContext();
       if (mc && mc->shouldMangleCXXName(nd)) {
         llvm::SmallVector<char, 1024> buf;
         llvm::raw_svector_ostream llvm_ostrm(buf);
if (nd != nullptr && !llvm::isa<clang::ObjCMethodDecl>(nd)) {
         if (buf.size() > 0)
           return ConstString(buf.data(), buf.size());
       }
     }
   }
   return ConstString();
 }
 
-CompilerDeclContext ClangASTContext::DeclGetDeclContext(void *opaque_decl) {
+CompilerDeclContext TypeSystemClang::DeclGetDeclContext(void *opaque_decl) {
   if (opaque_decl)
     return CreateDeclContext(((clang::Decl *)opaque_decl)->getDeclContext());
   return CompilerDeclContext();
 }
 
-CompilerType ClangASTContext::DeclGetFunctionReturnType(void *opaque_decl) {
+CompilerType TypeSystemClang::DeclGetFunctionReturnType(void *opaque_decl) {
   if (clang::FunctionDecl *func_decl =
           llvm::dyn_cast<clang::FunctionDecl>((clang::Decl *)opaque_decl))
     return GetType(func_decl->getReturnType());
   if (clang::ObjCMethodDecl *objc_method =
           llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl *)opaque_decl))
     return GetType(objc_method->getReturnType());
   else
     return CompilerType();
 }
 
-size_t ClangASTContext::DeclGetFunctionNumArguments(void *opaque_decl) {
+size_t TypeSystemClang::DeclGetFunctionNumArguments(void *opaque_decl) {
   if (clang::FunctionDecl *func_decl =
           llvm::dyn_cast<clang::FunctionDecl>((clang::Decl *)opaque_decl))
     return func_decl->param_size();
   if (clang::ObjCMethodDecl *objc_method =
           llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl *)opaque_decl))
     return objc_method->param_size();
   else
     return 0;
 }
 
-CompilerType ClangASTContext::DeclGetFunctionArgumentType(void *opaque_decl,
+CompilerType TypeSystemClang::DeclGetFunctionArgumentType(void *opaque_decl,
                                                           size_t idx) {
   if (clang::FunctionDecl *func_decl =
           llvm::dyn_cast<clang::FunctionDecl>((clang::Decl *)opaque_decl)) {
     if (idx < func_decl->param_size()) {
       ParmVarDecl *var_decl = func_decl->getParamDecl(idx);
       if (var_decl)
         return GetType(var_decl->getOriginalType());
     }
   } else if (clang::ObjCMethodDecl *objc_method =
                  llvm::dyn_cast<clang::ObjCMethodDecl>(
                      (clang::Decl *)opaque_decl)) {
     if (idx < objc_method->param_size())
       return GetType(objc_method->parameters()[idx]->getOriginalType());
   }
   return CompilerType();
 }
 
 // CompilerDeclContext functions
 
-std::vector<CompilerDecl> ClangASTContext::DeclContextFindDeclByName(
+std::vector<CompilerDecl> TypeSystemClang::DeclContextFindDeclByName(
     void *opaque_decl_ctx, ConstString name, const bool ignore_using_decls) {
   std::vector<CompilerDecl> found_decls;
   if (opaque_decl_ctx) {
     DeclContext *root_decl_ctx = (DeclContext *)opaque_decl_ctx;
     std::set<DeclContext *> searched;
     std::multimap<DeclContext *, DeclContext *> search_queue;
     SymbolFile *symbol_file = GetSymbolFile();
 

 //     }
 //
 // NOTE: Because file statics are at the TranslationUnit along with globals, a
 // function at file scope will return the same level as a function at global
 // scope. Ideally we'd like to treat the file scope as an additional scope just
 // below the global scope.  More work needs to be done to recognise that, if
 // the decl we're trying to look up is static, we should compare its source
 // file with that of the current scope and return a lower number for it.
-uint32_t ClangASTContext::CountDeclLevels(clang::DeclContext *frame_decl_ctx,
+uint32_t TypeSystemClang::CountDeclLevels(clang::DeclContext *frame_decl_ctx,
                                           clang::DeclContext *child_decl_ctx,
                                           ConstString *child_name,
                                           CompilerType *child_type) {
   if (frame_decl_ctx) {
     std::set<DeclContext *> searched;
     std::multimap<DeclContext *, DeclContext *> search_queue;
     SymbolFile *symbol_file = GetSymbolFile();
 
for (clang::DeclContext *decl_ctx = frame_decl_ctx; decl_ctx != nullptr;
         }
       }
       ++level;
     }
   }
   return LLDB_INVALID_DECL_LEVEL;
 }
 
-ConstString ClangASTContext::DeclContextGetName(void *opaque_decl_ctx) {
+ConstString TypeSystemClang::DeclContextGetName(void *opaque_decl_ctx) {
   if (opaque_decl_ctx) {
     clang::NamedDecl *named_decl =
         llvm::dyn_cast<clang::NamedDecl>((clang::DeclContext *)opaque_decl_ctx);
     if (named_decl)
       return ConstString(named_decl->getName());
   }
   return ConstString();
 }
 
 ConstString
-ClangASTContext::DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) {
+TypeSystemClang::DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) {
   if (opaque_decl_ctx) {
     clang::NamedDecl *named_decl =
         llvm::dyn_cast<clang::NamedDecl>((clang::DeclContext *)opaque_decl_ctx);
     if (named_decl)
       return ConstString(
           llvm::StringRef(named_decl->getQualifiedNameAsString()));
   }
   return ConstString();
 }
 
-bool ClangASTContext::DeclContextIsClassMethod(
+bool TypeSystemClang::DeclContextIsClassMethod(
     void *opaque_decl_ctx, lldb::LanguageType *language_ptr,
     bool *is_instance_method_ptr, ConstString *language_object_name_ptr) {
   if (opaque_decl_ctx) {
     clang::DeclContext *decl_ctx = (clang::DeclContext *)opaque_decl_ctx;
     if (ObjCMethodDecl *objc_method =
             llvm::dyn_cast<clang::ObjCMethodDecl>(decl_ctx)) {
       if (is_instance_method_ptr)
         *is_instance_method_ptr = objc_method->isInstanceMethod();
if (ObjCMethodDecl *objc_method =
           language_object_name_ptr->SetCString(metadata->GetObjectPtrName());
         return true;
       }
     }
   }
   return false;
 }
 
-bool ClangASTContext::DeclContextIsContainedInLookup(
+bool TypeSystemClang::DeclContextIsContainedInLookup(
     void *opaque_decl_ctx, void *other_opaque_decl_ctx) {
   auto *decl_ctx = (clang::DeclContext *)opaque_decl_ctx;
   auto *other = (clang::DeclContext *)other_opaque_decl_ctx;
 
   do {
     // A decl context always includes its own contents in its lookup.
     if (decl_ctx == other)
       return true;
 
     // If we have an inline namespace, then the lookup of the parent context
     // also includes the inline namespace contents.
   } while (other->isInlineNamespace() && (other = other->getParent()));
 
   return false;
 }
 
 static bool IsClangDeclContext(const CompilerDeclContext &dc) {
-  return dc.IsValid() && isa<ClangASTContext>(dc.GetTypeSystem());
+  return dc.IsValid() && isa<TypeSystemClang>(dc.GetTypeSystem());
 }
 
 clang::DeclContext *
-ClangASTContext::DeclContextGetAsDeclContext(const CompilerDeclContext &dc) {
+TypeSystemClang::DeclContextGetAsDeclContext(const CompilerDeclContext &dc) {
   if (IsClangDeclContext(dc))
     return (clang::DeclContext *)dc.GetOpaqueDeclContext();
   return nullptr;
 }
 
 ObjCMethodDecl *
-ClangASTContext::DeclContextGetAsObjCMethodDecl(const CompilerDeclContext &dc) {
+TypeSystemClang::DeclContextGetAsObjCMethodDecl(const CompilerDeclContext &dc) {
   if (IsClangDeclContext(dc))
     return llvm::dyn_cast<clang::ObjCMethodDecl>(
         (clang::DeclContext *)dc.GetOpaqueDeclContext());
   return nullptr;
 }
 
 CXXMethodDecl *
-ClangASTContext::DeclContextGetAsCXXMethodDecl(const CompilerDeclContext &dc) {
+TypeSystemClang::DeclContextGetAsCXXMethodDecl(const CompilerDeclContext &dc) {
   if (IsClangDeclContext(dc))
     return llvm::dyn_cast<clang::CXXMethodDecl>(
         (clang::DeclContext *)dc.GetOpaqueDeclContext());
   return nullptr;
 }
 
 clang::FunctionDecl *
-ClangASTContext::DeclContextGetAsFunctionDecl(const CompilerDeclContext &dc) {
+TypeSystemClang::DeclContextGetAsFunctionDecl(const CompilerDeclContext &dc) {
   if (IsClangDeclContext(dc))
     return llvm::dyn_cast<clang::FunctionDecl>(
         (clang::DeclContext *)dc.GetOpaqueDeclContext());
   return nullptr;
 }
 
 clang::NamespaceDecl *
-ClangASTContext::DeclContextGetAsNamespaceDecl(const CompilerDeclContext &dc) {
+TypeSystemClang::DeclContextGetAsNamespaceDecl(const CompilerDeclContext &dc) {
   if (IsClangDeclContext(dc))
     return llvm::dyn_cast<clang::NamespaceDecl>(
         (clang::DeclContext *)dc.GetOpaqueDeclContext());
   return nullptr;
 }
 
 ClangASTMetadata *
-ClangASTContext::DeclContextGetMetaData(const CompilerDeclContext &dc,
+TypeSystemClang::DeclContextGetMetaData(const CompilerDeclContext &dc,
                                         const Decl *object) {
-  ClangASTContext *ast = llvm::cast<ClangASTContext>(dc.GetTypeSystem());
+  TypeSystemClang *ast = llvm::cast<TypeSystemClang>(dc.GetTypeSystem());
   return ast->GetMetadata(object);
 }
 
 clang::ASTContext *
-ClangASTContext::DeclContextGetClangASTContext(const CompilerDeclContext &dc) {
-  ClangASTContext *ast =
-      llvm::dyn_cast_or_null<ClangASTContext>(dc.GetTypeSystem());
+TypeSystemClang::DeclContextGetTypeSystemClang(const CompilerDeclContext &dc) {
+  TypeSystemClang *ast =
+      llvm::dyn_cast_or_null<TypeSystemClang>(dc.GetTypeSystem());
   if (ast)
     return &ast->getASTContext();
   return nullptr;
 }
 
-ClangASTContextForExpressions::ClangASTContextForExpressions(
+TypeSystemClangForExpressions::TypeSystemClangForExpressions(
     Target &target, llvm::Triple triple)
-    : ClangASTContext("scratch ASTContext", triple),
+    : TypeSystemClang("scratch ASTContext", triple),
       m_target_wp(target.shared_from_this()),
       m_persistent_variables(new ClangPersistentVariables) {
   m_scratch_ast_source_up.reset(new ClangASTSource(
       target.shared_from_this(), target.GetClangASTImporter()));
   m_scratch_ast_source_up->InstallASTContext(*this);
   llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> proxy_ast_source(
       m_scratch_ast_source_up->CreateProxy());
   SetExternalSource(proxy_ast_source);
 }
 
-void ClangASTContextForExpressions::Finalize() {
-  ClangASTContext::Finalize();
+void TypeSystemClangForExpressions::Finalize() {
+  TypeSystemClang::Finalize();
   m_scratch_ast_source_up.reset();
 }
 
-UserExpression *ClangASTContextForExpressions::GetUserExpression(
+UserExpression *TypeSystemClangForExpressions::GetUserExpression(
     llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language,
     Expression::ResultType desired_type,
     const EvaluateExpressionOptions &options,
     ValueObject *ctx_obj) {
   TargetSP target_sp = m_target_wp.lock();
   if (!target_sp)
     return nullptr;
 
   return new ClangUserExpression(*target_sp.get(), expr, prefix, language,
                                  desired_type, options, ctx_obj);
 }
 
-FunctionCaller *ClangASTContextForExpressions::GetFunctionCaller(
+FunctionCaller *TypeSystemClangForExpressions::GetFunctionCaller(
     const CompilerType &return_type, const Address &function_address,
     const ValueList &arg_value_list, const char *name) {
   TargetSP target_sp = m_target_wp.lock();
   if (!target_sp)
     return nullptr;
 
   Process *process = target_sp->GetProcessSP().get();
   if (!process)
     return nullptr;
 
   return new ClangFunctionCaller(*process, return_type, function_address,
                                  arg_value_list, name);
 }
 
 UtilityFunction *
-ClangASTContextForExpressions::GetUtilityFunction(const char *text,
+TypeSystemClangForExpressions::GetUtilityFunction(const char *text,
                                                   const char *name) {
   TargetSP target_sp = m_target_wp.lock();
   if (!target_sp)
     return nullptr;
 
   return new ClangUtilityFunction(*target_sp.get(), text, name);
 }
 
 PersistentExpressionState *
-ClangASTContextForExpressions::GetPersistentExpressionState() {
+TypeSystemClangForExpressions::GetPersistentExpressionState() {
   return m_persistent_variables.get();
 }

lldb/tools/lldb-test/SystemInitializerTest.cpp

 //===-- SystemInitializerTest.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 "SystemInitializerTest.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Initialization/SystemInitializerCommon.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Utility/Timer.h"
 
 #include "Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h"
 #include "Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h"
 #include "Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h"
 #include "Plugins/ABI/SysV-arc/ABISysV_arc.h"
 #include "Plugins/ABI/SysV-arm/ABISysV_arm.h"
 #include "Plugins/ABI/SysV-arm64/ABISysV_arm64.h"
llvm::Error SystemInitializerTest::Initialize() {
   PlatformMacOSX::Initialize();
 
   // Initialize LLVM and Clang
   llvm::InitializeAllTargets();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
-  ClangASTContext::Initialize();
+  TypeSystemClang::Initialize();
 
 #define LLVM_TARGET(t) LLDB_PROCESS_ ## t(Initialize)
 #include "llvm/Config/Targets.def"
 
   ArchitectureArm::Initialize();
   ArchitectureMips::Initialize();
   ArchitecturePPC64::Initialize();
 
void SystemInitializerTest::Terminate() {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   Debugger::SettingsTerminate();
 
   // Terminate and unload and loaded system or user LLDB plug-ins
   PluginManager::Terminate();
 
-  ClangASTContext::Terminate();
+  TypeSystemClang::Terminate();
 
   ArchitectureArm::Terminate();
   ArchitectureMips::Terminate();
   ArchitecturePPC64::Terminate();
 
 #define LLVM_TARGET(t) LLDB_PROCESS_ ## t(Terminate)
 #include "llvm/Config/Targets.def"
 

lldb/tools/lldb-test/lldb-test.cpp

 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Expression/IRMemoryMap.h"
 #include "lldb/Initialization/SystemLifetimeManager.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
Error opts::symbols::dumpAST(lldb_private::Module &Module) {
 
   SymbolFile *symfile = Module.GetSymbolFile();
   if (!symfile)
     return make_string_error("Module has no symbol file.");
 
   llvm::Expected<TypeSystem &> type_system_or_err =
       symfile->GetTypeSystemForLanguage(eLanguageTypeC_plus_plus);
   if (!type_system_or_err)
-    return make_string_error("Can't retrieve ClangASTContext");
+    return make_string_error("Can't retrieve TypeSystemClang");
 
   auto *clang_ast_ctx =
-      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+      llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_ast_ctx)
-    return make_string_error("Retrieved TypeSystem was not a ClangASTContext");
+    return make_string_error("Retrieved TypeSystem was not a TypeSystemClang");
 
   clang::ASTContext &ast_ctx = clang_ast_ctx->getASTContext();
 
   clang::TranslationUnitDecl *tu = ast_ctx.getTranslationUnitDecl();
   if (!tu)
     return make_string_error("Can't retrieve translation unit declaration.");
 
   tu->print(outs());
 
   return Error::success();
 }
 
 Error opts::symbols::dumpClangAST(lldb_private::Module &Module) {
   Module.ParseAllDebugSymbols();
 
   SymbolFile *symfile = Module.GetSymbolFile();
   if (!symfile)
     return make_string_error("Module has no symbol file.");
 
   llvm::Expected<TypeSystem &> type_system_or_err =
       symfile->GetTypeSystemForLanguage(eLanguageTypeObjC_plus_plus);
   if (!type_system_or_err)
-    return make_string_error("Can't retrieve ClangASTContext");
+    return make_string_error("Can't retrieve TypeSystemClang");
 
   auto *clang_ast_ctx =
-      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+      llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_ast_ctx)
-    return make_string_error("Retrieved TypeSystem was not a ClangASTContext");
+    return make_string_error("Retrieved TypeSystem was not a TypeSystemClang");
 
   StreamString Stream;
   clang_ast_ctx->DumpFromSymbolFile(Stream, Name);
   outs() << Stream.GetData() << "\n";
 
   return Error::success();
 }
 

lldb/unittests/Expression/ClangExpressionDeclMapTest.cpp

 //===-- ClangExpressionDeclMapTest.cpp ------------------------------------===//
 //
 // 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 "Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h"
 #include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/Symbol/ClangTestUtils.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangUtil.h"
 #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)
       : ClangExpressionDeclMap(false, nullptr, lldb::TargetSP(), importer,
                                nullptr) {
     m_scratch_context = clang_utils::createAST();
   }
-  std::unique_ptr<ClangASTContext> m_scratch_context;
+  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) {
     // The declaration needs to have '$' prefix in its name like every
     // persistent declaration and must be inside the scratch AST context.
     assert(d);
     assert(d->getName().startswith("$"));
     assert(&d->getASTContext() == &m_scratch_context->getASTContext());
struct ClangExpressionDeclMapTest : public testing::Test {
   SubsystemRAII<FileSystem, HostInfo> subsystems;
 
   /// The ClangASTImporter used during the test.
   ClangASTImporterSP 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<ClangASTContext> target_ast;
+  std::unique_ptr<TypeSystemClang> target_ast;
 
   void SetUp() override {
     importer = std::make_shared<ClangASTImporter>();
     decl_map = std::make_unique<FakeClangExpressionDeclMap>(importer);
     target_ast = clang_utils::createAST();
     decl_map->InstallASTContext(*target_ast);
   }
 

lldb/unittests/Symbol/CMakeLists.txt

 add_lldb_unittest(SymbolTests
   LocateSymbolFileTest.cpp
   PostfixExpressionTest.cpp
-  TestClangASTContext.cpp
+  TestTypeSystemClang.cpp
   TestClangASTImporter.cpp
   TestDWARFCallFrameInfo.cpp
   TestType.cpp
   TestLineEntry.cpp
 
   LINK_LIBS
     lldbHost
     lldbSymbol

lldb/unittests/Symbol/TestClangASTImporter.cpp

 //===-- TestClangASTImporter.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 "gtest/gtest.h"
 
 #include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/Symbol/ClangTestUtils.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/ClangASTMetadata.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/Declaration.h"
 #include "clang/AST/DeclCXX.h"
 
 using namespace clang;
 using namespace lldb;
TEST_F(TestClangASTImporter, ImportInvalidType) {
   ClangASTImporter importer;
   EXPECT_FALSE(importer.Import(CompilerType()));
 }
 
 TEST_F(TestClangASTImporter, CopyDeclTagDecl) {
   // Tests that the ClangASTImporter::CopyDecl can copy TagDecls.
   clang_utils::SourceASTWithRecord source;
 
-  std::unique_ptr<ClangASTContext> target_ast = clang_utils::createAST();
+  std::unique_ptr<TypeSystemClang> target_ast = clang_utils::createAST();
 
   ClangASTImporter importer;
   clang::Decl *imported =
       importer.CopyDecl(&target_ast->getASTContext(), source.record_decl);
   ASSERT_NE(nullptr, imported);
 
   // Check that we got the correct decl by just comparing their qualified name.
   clang::TagDecl *imported_tag_decl = llvm::cast<clang::TagDecl>(imported);
   EXPECT_EQ(source.record_decl->getQualifiedNameAsString(),
             imported_tag_decl->getQualifiedNameAsString());
   // We did a minimal import of the tag decl.
   EXPECT_TRUE(imported_tag_decl->hasExternalLexicalStorage());
 
   // Check that origin was set for the imported declaration.
   ClangASTImporter::DeclOrigin origin = importer.GetDeclOrigin(imported);
   EXPECT_TRUE(origin.Valid());
   EXPECT_EQ(origin.ctx, &source.ast->getASTContext());
   EXPECT_EQ(origin.decl, source.record_decl);
 }
 
 TEST_F(TestClangASTImporter, CopyTypeTagDecl) {
   // Tests that the ClangASTImporter::CopyType can copy TagDecls types.
   clang_utils::SourceASTWithRecord source;
 
-  std::unique_ptr<ClangASTContext> target_ast = clang_utils::createAST();
+  std::unique_ptr<TypeSystemClang> target_ast = clang_utils::createAST();
 
   ClangASTImporter importer;
   CompilerType imported = importer.CopyType(*target_ast, source.record_type);
   ASSERT_TRUE(imported.IsValid());
 
   // Check that we got the correct decl by just comparing their qualified name.
   clang::TagDecl *imported_tag_decl = ClangUtil::GetAsTagDecl(imported);
   EXPECT_EQ(source.record_decl->getQualifiedNameAsString(),
             imported_tag_decl->getQualifiedNameAsString());
   // We did a minimal import of the tag decl.
   EXPECT_TRUE(imported_tag_decl->hasExternalLexicalStorage());
 
   // Check that origin was set for the imported declaration.
   ClangASTImporter::DeclOrigin origin =
       importer.GetDeclOrigin(imported_tag_decl);
   EXPECT_TRUE(origin.Valid());
   EXPECT_EQ(origin.ctx, &source.ast->getASTContext());
   EXPECT_EQ(origin.decl, source.record_decl);
 }
 
 TEST_F(TestClangASTImporter, DeportDeclTagDecl) {
   // Tests that the ClangASTImporter::DeportDecl completely copies TagDecls.
   clang_utils::SourceASTWithRecord source;
 
-  std::unique_ptr<ClangASTContext> target_ast = clang_utils::createAST();
+  std::unique_ptr<TypeSystemClang> target_ast = clang_utils::createAST();
 
   ClangASTImporter importer;
   clang::Decl *imported =
       importer.DeportDecl(&target_ast->getASTContext(), source.record_decl);
   ASSERT_NE(nullptr, imported);
 
   // Check that we got the correct decl by just comparing their qualified name.
   clang::TagDecl *imported_tag_decl = llvm::cast<clang::TagDecl>(imported);
   EXPECT_EQ(source.record_decl->getQualifiedNameAsString(),
             imported_tag_decl->getQualifiedNameAsString());
   // The record should be completed as we deported it.
   EXPECT_FALSE(imported_tag_decl->hasExternalLexicalStorage());
 
   // Deporting doesn't update the origin map.
   EXPECT_FALSE(importer.GetDeclOrigin(imported_tag_decl).Valid());
 }
 
 TEST_F(TestClangASTImporter, DeportTypeTagDecl) {
   // Tests that the ClangASTImporter::CopyType can deport TagDecl types.
   clang_utils::SourceASTWithRecord source;
 
-  std::unique_ptr<ClangASTContext> target_ast = clang_utils::createAST();
+  std::unique_ptr<TypeSystemClang> target_ast = clang_utils::createAST();
 
   ClangASTImporter importer;
   CompilerType imported = importer.DeportType(*target_ast, source.record_type);
   ASSERT_TRUE(imported.IsValid());
 
   // Check that we got the correct decl by just comparing their qualified name.
   clang::TagDecl *imported_tag_decl = ClangUtil::GetAsTagDecl(imported);
   EXPECT_EQ(source.record_decl->getQualifiedNameAsString(),
             imported_tag_decl->getQualifiedNameAsString());
   // The record should be completed as we deported it.
   EXPECT_FALSE(imported_tag_decl->hasExternalLexicalStorage());
 
   // Deporting doesn't update the origin map.
   EXPECT_FALSE(importer.GetDeclOrigin(imported_tag_decl).Valid());
 }
 
 TEST_F(TestClangASTImporter, MetadataPropagation) {
   // Tests that AST metadata is propagated when copying declarations.
 
   clang_utils::SourceASTWithRecord source;
 
   const lldb::user_id_t metadata = 123456;
   source.ast->SetMetadataAsUserID(source.record_decl, metadata);
 
-  std::unique_ptr<ClangASTContext> target_ast = clang_utils::createAST();
+  std::unique_ptr<TypeSystemClang> target_ast = clang_utils::createAST();
 
   ClangASTImporter importer;
   clang::Decl *imported =
       importer.CopyDecl(&target_ast->getASTContext(), source.record_decl);
   ASSERT_NE(nullptr, imported);
 
   // Check that we got the same Metadata.
   ASSERT_NE(nullptr, importer.GetDeclMetadata(imported));
   EXPECT_EQ(metadata, importer.GetDeclMetadata(imported)->GetUserID());
 }
 
 TEST_F(TestClangASTImporter, MetadataPropagationIndirectImport) {
   // Tests that AST metadata is propagated when copying declarations when
   // importing one declaration into a temporary context and then to the
   // actual destination context.
 
   clang_utils::SourceASTWithRecord source;
 
   const lldb::user_id_t metadata = 123456;
   source.ast->SetMetadataAsUserID(source.record_decl, metadata);
 
-  std::unique_ptr<ClangASTContext> temporary_ast = clang_utils::createAST();
+  std::unique_ptr<TypeSystemClang> temporary_ast = clang_utils::createAST();
 
   ClangASTImporter importer;
   clang::Decl *temporary_imported =
       importer.CopyDecl(&temporary_ast->getASTContext(), source.record_decl);
   ASSERT_NE(nullptr, temporary_imported);
 
-  std::unique_ptr<ClangASTContext> target_ast = clang_utils::createAST();
+  std::unique_ptr<TypeSystemClang> target_ast = clang_utils::createAST();
   clang::Decl *imported =
       importer.CopyDecl(&target_ast->getASTContext(), temporary_imported);
   ASSERT_NE(nullptr, imported);
 
   // Check that we got the same Metadata.
   ASSERT_NE(nullptr, importer.GetDeclMetadata(imported));
   EXPECT_EQ(metadata, importer.GetDeclMetadata(imported)->GetUserID());
 }
 
 TEST_F(TestClangASTImporter, MetadataPropagationAfterCopying) {
   // Tests that AST metadata is propagated when copying declarations even
   // when the metadata was set after the declaration has already been copied.
 
   clang_utils::SourceASTWithRecord source;
   const lldb::user_id_t metadata = 123456;
 
-  std::unique_ptr<ClangASTContext> target_ast = clang_utils::createAST();
+  std::unique_ptr<TypeSystemClang> target_ast = clang_utils::createAST();
 
   ClangASTImporter importer;
   clang::Decl *imported =
       importer.CopyDecl(&target_ast->getASTContext(), source.record_decl);
   ASSERT_NE(nullptr, imported);
 
   // The TagDecl has been imported. Now set the metadata of the source and
   // make sure the imported one will directly see it.

lldb/unittests/Symbol/TestLineEntry.cpp

 #include "gtest/gtest.h"
 #include <iostream>
 
 #include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
 #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContext.h"
 
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 class LineEntryTest : public testing::Test {
   SubsystemRAII<FileSystem, HostInfo, ObjectFileMachO, SymbolFileDWARF,
-                ClangASTContext>
+                TypeSystemClang>
       subsystem;
 
 public:
   void SetUp() override;
 
 protected:
   llvm::Expected<LineEntry> GetLineEntryForLine(uint32_t line);
   llvm::Optional<TestFile> m_file;

lldb/unittests/Symbol/TestTypeSystemClang.cpp

-//===-- TestClangASTContext.cpp ---------------------------------*- C++ -*-===//
+//===-- TestTypeSystemClang.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 "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/Symbol/ClangTestUtils.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/Declaration.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/ExprCXX.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace lldb;
 using namespace lldb_private;
 
-class TestClangASTContext : public testing::Test {
+class TestTypeSystemClang : public testing::Test {
 public:
   SubsystemRAII<FileSystem, HostInfo> subsystems;
 
   void SetUp() override {
     m_ast.reset(
-        new ClangASTContext("test ASTContext", HostInfo::GetTargetTriple()));
+        new TypeSystemClang("test ASTContext", HostInfo::GetTargetTriple()));
   }
 
   void TearDown() override { m_ast.reset(); }
 
 protected:
-  std::unique_ptr<ClangASTContext> m_ast;
+  std::unique_ptr<TypeSystemClang> m_ast;
 
   QualType GetBasicQualType(BasicType type) const {
     return ClangUtil::GetQualType(m_ast->GetBasicTypeFromAST(type));
   }
 
   QualType GetBasicQualType(const char *name) const {
     return ClangUtil::GetQualType(
         m_ast->GetBuiltinTypeByName(ConstString(name)));
   }
 };
 
-TEST_F(TestClangASTContext, TestGetBasicTypeFromEnum) {
+TEST_F(TestTypeSystemClang, TestGetBasicTypeFromEnum) {
   clang::ASTContext &context = m_ast->getASTContext();
 
   EXPECT_TRUE(
       context.hasSameType(GetBasicQualType(eBasicTypeBool), context.BoolTy));
   EXPECT_TRUE(
       context.hasSameType(GetBasicQualType(eBasicTypeChar), context.CharTy));
   EXPECT_TRUE(context.hasSameType(GetBasicQualType(eBasicTypeChar16),
                                   context.Char16Ty));
TEST_F(TestTypeSystemClang, TestGetBasicTypeFromEnum) {
   EXPECT_TRUE(context.hasSameType(GetBasicQualType(eBasicTypeUnsignedShort),
                                   context.UnsignedShortTy));
   EXPECT_TRUE(
       context.hasSameType(GetBasicQualType(eBasicTypeVoid), context.VoidTy));
   EXPECT_TRUE(
       context.hasSameType(GetBasicQualType(eBasicTypeWChar), context.WCharTy));
 }
 
-TEST_F(TestClangASTContext, TestGetBasicTypeFromName) {
+TEST_F(TestTypeSystemClang, TestGetBasicTypeFromName) {
   EXPECT_EQ(GetBasicQualType(eBasicTypeChar), GetBasicQualType("char"));
   EXPECT_EQ(GetBasicQualType(eBasicTypeSignedChar),
             GetBasicQualType("signed char"));
   EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedChar),
             GetBasicQualType("unsigned char"));
   EXPECT_EQ(GetBasicQualType(eBasicTypeWChar), GetBasicQualType("wchar_t"));
   EXPECT_EQ(GetBasicQualType(eBasicTypeSignedWChar),
             GetBasicQualType("signed wchar_t"));
TEST_F(TestTypeSystemClang, TestGetBasicTypeFromName) {
   EXPECT_EQ(GetBasicQualType(eBasicTypeDouble), GetBasicQualType("double"));
   EXPECT_EQ(GetBasicQualType(eBasicTypeLongDouble),
             GetBasicQualType("long double"));
   EXPECT_EQ(GetBasicQualType(eBasicTypeObjCID), GetBasicQualType("id"));
   EXPECT_EQ(GetBasicQualType(eBasicTypeObjCSel), GetBasicQualType("SEL"));
   EXPECT_EQ(GetBasicQualType(eBasicTypeNullPtr), GetBasicQualType("nullptr"));
 }
 
-void VerifyEncodingAndBitSize(ClangASTContext &clang_context,
+void VerifyEncodingAndBitSize(TypeSystemClang &clang_context,
                               lldb::Encoding encoding, unsigned int bit_size) {
   clang::ASTContext &context = clang_context.getASTContext();
 
   CompilerType type =
       clang_context.GetBuiltinTypeForEncodingAndBitSize(encoding, bit_size);
   EXPECT_TRUE(type.IsValid());
 
   QualType qtype = ClangUtil::GetQualType(type);
case eEncodingIEEE754:
     EXPECT_TRUE(type_ptr->isFloatingType());
     break;
   default:
     FAIL() << "Unexpected encoding";
     break;
   }
 }
 
-TEST_F(TestClangASTContext, TestBuiltinTypeForEncodingAndBitSize) {
+TEST_F(TestTypeSystemClang, TestBuiltinTypeForEncodingAndBitSize) {
   // Make sure we can get types of every possible size in every possible
   // encoding.
   // We can't make any guarantee about which specific type we get, because the
   // standard
   // isn't that specific.  We only need to make sure the compiler hands us some
   // type that
   // is both a builtin type and matches the requested bit size.
   VerifyEncodingAndBitSize(*m_ast, eEncodingSint, 8);
   VerifyEncodingAndBitSize(*m_ast, eEncodingSint, 16);
   VerifyEncodingAndBitSize(*m_ast, eEncodingSint, 32);
   VerifyEncodingAndBitSize(*m_ast, eEncodingSint, 64);
   VerifyEncodingAndBitSize(*m_ast, eEncodingSint, 128);
 
   VerifyEncodingAndBitSize(*m_ast, eEncodingUint, 8);
   VerifyEncodingAndBitSize(*m_ast, eEncodingUint, 16);
   VerifyEncodingAndBitSize(*m_ast, eEncodingUint, 32);
   VerifyEncodingAndBitSize(*m_ast, eEncodingUint, 64);
   VerifyEncodingAndBitSize(*m_ast, eEncodingUint, 128);
 
   VerifyEncodingAndBitSize(*m_ast, eEncodingIEEE754, 32);
   VerifyEncodingAndBitSize(*m_ast, eEncodingIEEE754, 64);
 }
 
-TEST_F(TestClangASTContext, TestDisplayName) {
-  ClangASTContext ast("some name", llvm::Triple());
+TEST_F(TestTypeSystemClang, TestDisplayName) {
+  TypeSystemClang ast("some name", llvm::Triple());
   EXPECT_EQ("some name", ast.getDisplayName());
 }
 
-TEST_F(TestClangASTContext, TestDisplayNameEmpty) {
-  ClangASTContext ast("", llvm::Triple());
+TEST_F(TestTypeSystemClang, TestDisplayNameEmpty) {
+  TypeSystemClang ast("", llvm::Triple());
   EXPECT_EQ("", ast.getDisplayName());
 }
 
-TEST_F(TestClangASTContext, TestIsClangType) {
+TEST_F(TestTypeSystemClang, TestIsClangType) {
   clang::ASTContext &context = m_ast->getASTContext();
   lldb::opaque_compiler_type_t bool_ctype =
-      ClangASTContext::GetOpaqueCompilerType(&context, lldb::eBasicTypeBool);
+      TypeSystemClang::GetOpaqueCompilerType(&context, lldb::eBasicTypeBool);
   CompilerType bool_type(m_ast.get(), bool_ctype);
   CompilerType record_type = m_ast->CreateRecordType(
       nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct,
       lldb::eLanguageTypeC_plus_plus, nullptr);
   // Clang builtin type and record type should pass
   EXPECT_TRUE(ClangUtil::IsClangType(bool_type));
   EXPECT_TRUE(ClangUtil::IsClangType(record_type));
 
   // Default constructed type should fail
   EXPECT_FALSE(ClangUtil::IsClangType(CompilerType()));
 }
 
-TEST_F(TestClangASTContext, TestRemoveFastQualifiers) {
+TEST_F(TestTypeSystemClang, TestRemoveFastQualifiers) {
   CompilerType record_type = m_ast->CreateRecordType(
       nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct,
       lldb::eLanguageTypeC_plus_plus, nullptr);
   QualType qt;
 
   qt = ClangUtil::GetQualType(record_type);
   EXPECT_EQ(0u, qt.getLocalFastQualifiers());
   record_type = record_type.AddConstModifier();
   record_type = record_type.AddVolatileModifier();
   record_type = record_type.AddRestrictModifier();
   qt = ClangUtil::GetQualType(record_type);
   EXPECT_NE(0u, qt.getLocalFastQualifiers());
   record_type = ClangUtil::RemoveFastQualifiers(record_type);
   qt = ClangUtil::GetQualType(record_type);
   EXPECT_EQ(0u, qt.getLocalFastQualifiers());
 }
 
-TEST_F(TestClangASTContext, TestConvertAccessTypeToAccessSpecifier) {
+TEST_F(TestTypeSystemClang, TestConvertAccessTypeToAccessSpecifier) {
   EXPECT_EQ(AS_none,
-            ClangASTContext::ConvertAccessTypeToAccessSpecifier(eAccessNone));
-  EXPECT_EQ(AS_none, ClangASTContext::ConvertAccessTypeToAccessSpecifier(
+            TypeSystemClang::ConvertAccessTypeToAccessSpecifier(eAccessNone));
+  EXPECT_EQ(AS_none, TypeSystemClang::ConvertAccessTypeToAccessSpecifier(
                          eAccessPackage));
   EXPECT_EQ(AS_public,
-            ClangASTContext::ConvertAccessTypeToAccessSpecifier(eAccessPublic));
-  EXPECT_EQ(AS_private, ClangASTContext::ConvertAccessTypeToAccessSpecifier(
+            TypeSystemClang::ConvertAccessTypeToAccessSpecifier(eAccessPublic));
+  EXPECT_EQ(AS_private, TypeSystemClang::ConvertAccessTypeToAccessSpecifier(
                             eAccessPrivate));
-  EXPECT_EQ(AS_protected, ClangASTContext::ConvertAccessTypeToAccessSpecifier(
+  EXPECT_EQ(AS_protected, TypeSystemClang::ConvertAccessTypeToAccessSpecifier(
                               eAccessProtected));
 }
 
-TEST_F(TestClangASTContext, TestUnifyAccessSpecifiers) {
+TEST_F(TestTypeSystemClang, TestUnifyAccessSpecifiers) {
   // Unifying two of the same type should return the same type
   EXPECT_EQ(AS_public,
-            ClangASTContext::UnifyAccessSpecifiers(AS_public, AS_public));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_public, AS_public));
   EXPECT_EQ(AS_private,
-            ClangASTContext::UnifyAccessSpecifiers(AS_private, AS_private));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_private, AS_private));
   EXPECT_EQ(AS_protected,
-            ClangASTContext::UnifyAccessSpecifiers(AS_protected, AS_protected));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_protected, AS_protected));
 
   // Otherwise the result should be the strictest of the two.
   EXPECT_EQ(AS_private,
-            ClangASTContext::UnifyAccessSpecifiers(AS_private, AS_public));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_private, AS_public));
   EXPECT_EQ(AS_private,
-            ClangASTContext::UnifyAccessSpecifiers(AS_private, AS_protected));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_private, AS_protected));
   EXPECT_EQ(AS_private,
-            ClangASTContext::UnifyAccessSpecifiers(AS_public, AS_private));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_public, AS_private));
   EXPECT_EQ(AS_private,
-            ClangASTContext::UnifyAccessSpecifiers(AS_protected, AS_private));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_protected, AS_private));
   EXPECT_EQ(AS_protected,
-            ClangASTContext::UnifyAccessSpecifiers(AS_protected, AS_public));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_protected, AS_public));
   EXPECT_EQ(AS_protected,
-            ClangASTContext::UnifyAccessSpecifiers(AS_public, AS_protected));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_public, AS_protected));
 
   // None is stricter than everything (by convention)
   EXPECT_EQ(AS_none,
-            ClangASTContext::UnifyAccessSpecifiers(AS_none, AS_public));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_none, AS_public));
   EXPECT_EQ(AS_none,
-            ClangASTContext::UnifyAccessSpecifiers(AS_none, AS_protected));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_none, AS_protected));
   EXPECT_EQ(AS_none,
-            ClangASTContext::UnifyAccessSpecifiers(AS_none, AS_private));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_none, AS_private));
   EXPECT_EQ(AS_none,
-            ClangASTContext::UnifyAccessSpecifiers(AS_public, AS_none));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_public, AS_none));
   EXPECT_EQ(AS_none,
-            ClangASTContext::UnifyAccessSpecifiers(AS_protected, AS_none));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_protected, AS_none));
   EXPECT_EQ(AS_none,
-            ClangASTContext::UnifyAccessSpecifiers(AS_private, AS_none));
+            TypeSystemClang::UnifyAccessSpecifiers(AS_private, AS_none));
 }
 
-TEST_F(TestClangASTContext, TestRecordHasFields) {
+TEST_F(TestTypeSystemClang, TestRecordHasFields) {
   CompilerType int_type = m_ast->GetBasicType(eBasicTypeInt);
 
   // Test that a record with no fields returns false
   CompilerType empty_base = m_ast->CreateRecordType(
       nullptr, lldb::eAccessPublic, "EmptyBase", clang::TTK_Struct,
       lldb::eLanguageTypeC_plus_plus, nullptr);
-  ClangASTContext::StartTagDeclarationDefinition(empty_base);
-  ClangASTContext::CompleteTagDeclarationDefinition(empty_base);
+  TypeSystemClang::StartTagDeclarationDefinition(empty_base);
+  TypeSystemClang::CompleteTagDeclarationDefinition(empty_base);
 
-  RecordDecl *empty_base_decl = ClangASTContext::GetAsRecordDecl(empty_base);
+  RecordDecl *empty_base_decl = TypeSystemClang::GetAsRecordDecl(empty_base);
   EXPECT_NE(nullptr, empty_base_decl);
-  EXPECT_FALSE(ClangASTContext::RecordHasFields(empty_base_decl));
+  EXPECT_FALSE(TypeSystemClang::RecordHasFields(empty_base_decl));
 
   // Test that a record with direct fields returns true
   CompilerType non_empty_base = m_ast->CreateRecordType(
       nullptr, lldb::eAccessPublic, "NonEmptyBase", clang::TTK_Struct,
       lldb::eLanguageTypeC_plus_plus, nullptr);
-  ClangASTContext::StartTagDeclarationDefinition(non_empty_base);
+  TypeSystemClang::StartTagDeclarationDefinition(non_empty_base);
   FieldDecl *non_empty_base_field_decl = m_ast->AddFieldToRecordType(
       non_empty_base, "MyField", int_type, eAccessPublic, 0);
-  ClangASTContext::CompleteTagDeclarationDefinition(non_empty_base);
+  TypeSystemClang::CompleteTagDeclarationDefinition(non_empty_base);
   RecordDecl *non_empty_base_decl =
-      ClangASTContext::GetAsRecordDecl(non_empty_base);
+      TypeSystemClang::GetAsRecordDecl(non_empty_base);
   EXPECT_NE(nullptr, non_empty_base_decl);
   EXPECT_NE(nullptr, non_empty_base_field_decl);
-  EXPECT_TRUE(ClangASTContext::RecordHasFields(non_empty_base_decl));
+  EXPECT_TRUE(TypeSystemClang::RecordHasFields(non_empty_base_decl));
 
   std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases;
 
   // Test that a record with no direct fields, but fields in a base returns true
   CompilerType empty_derived = m_ast->CreateRecordType(
       nullptr, lldb::eAccessPublic, "EmptyDerived", clang::TTK_Struct,
       lldb::eLanguageTypeC_plus_plus, nullptr);
-  ClangASTContext::StartTagDeclarationDefinition(empty_derived);
+  TypeSystemClang::StartTagDeclarationDefinition(empty_derived);
   std::unique_ptr<clang::CXXBaseSpecifier> non_empty_base_spec =
       m_ast->CreateBaseClassSpecifier(non_empty_base.GetOpaqueQualType(),
                                       lldb::eAccessPublic, false, false);
   bases.push_back(std::move(non_empty_base_spec));
   bool result = m_ast->TransferBaseClasses(empty_derived.GetOpaqueQualType(),
                                            std::move(bases));
-  ClangASTContext::CompleteTagDeclarationDefinition(empty_derived);
+  TypeSystemClang::CompleteTagDeclarationDefinition(empty_derived);
   EXPECT_TRUE(result);
   CXXRecordDecl *empty_derived_non_empty_base_cxx_decl =
       m_ast->GetAsCXXRecordDecl(empty_derived.GetOpaqueQualType());
   RecordDecl *empty_derived_non_empty_base_decl =
-      ClangASTContext::GetAsRecordDecl(empty_derived);
-  EXPECT_EQ(1u, ClangASTContext::GetNumBaseClasses(
+      TypeSystemClang::GetAsRecordDecl(empty_derived);
+  EXPECT_EQ(1u, TypeSystemClang::GetNumBaseClasses(
                     empty_derived_non_empty_base_cxx_decl, false));
   EXPECT_TRUE(
-      ClangASTContext::RecordHasFields(empty_derived_non_empty_base_decl));
+      TypeSystemClang::RecordHasFields(empty_derived_non_empty_base_decl));
 
   // Test that a record with no direct fields, but fields in a virtual base
   // returns true
   CompilerType empty_derived2 = m_ast->CreateRecordType(
       nullptr, lldb::eAccessPublic, "EmptyDerived2", clang::TTK_Struct,
       lldb::eLanguageTypeC_plus_plus, nullptr);
-  ClangASTContext::StartTagDeclarationDefinition(empty_derived2);
+  TypeSystemClang::StartTagDeclarationDefinition(empty_derived2);
   std::unique_ptr<CXXBaseSpecifier> non_empty_vbase_spec =
       m_ast->CreateBaseClassSpecifier(non_empty_base.GetOpaqueQualType(),
                                       lldb::eAccessPublic, true, false);
   bases.push_back(std::move(non_empty_vbase_spec));
   result = m_ast->TransferBaseClasses(empty_derived2.GetOpaqueQualType(),
                                       std::move(bases));
-  ClangASTContext::CompleteTagDeclarationDefinition(empty_derived2);
+  TypeSystemClang::CompleteTagDeclarationDefinition(empty_derived2);
   EXPECT_TRUE(result);
   CXXRecordDecl *empty_derived_non_empty_vbase_cxx_decl =
       m_ast->GetAsCXXRecordDecl(empty_derived2.GetOpaqueQualType());
   RecordDecl *empty_derived_non_empty_vbase_decl =
-      ClangASTContext::GetAsRecordDecl(empty_derived2);
-  EXPECT_EQ(1u, ClangASTContext::GetNumBaseClasses(
+      TypeSystemClang::GetAsRecordDecl(empty_derived2);
+  EXPECT_EQ(1u, TypeSystemClang::GetNumBaseClasses(
                     empty_derived_non_empty_vbase_cxx_decl, false));
   EXPECT_TRUE(
-      ClangASTContext::RecordHasFields(empty_derived_non_empty_vbase_decl));
+      TypeSystemClang::RecordHasFields(empty_derived_non_empty_vbase_decl));
 }
 
-TEST_F(TestClangASTContext, TemplateArguments) {
-  ClangASTContext::TemplateParameterInfos infos;
+TEST_F(TestTypeSystemClang, TemplateArguments) {
+  TypeSystemClang::TemplateParameterInfos infos;
   infos.names.push_back("T");
   infos.args.push_back(TemplateArgument(m_ast->getASTContext().IntTy));
   infos.names.push_back("I");
   llvm::APSInt arg(llvm::APInt(8, 47));
   infos.args.push_back(TemplateArgument(m_ast->getASTContext(), arg,
                                         m_ast->getASTContext().IntTy));
 
   // template<typename T, int I> struct foo;

 }
 
 static QualType makeConstInt(clang::ASTContext &ctxt) {
   QualType result(ctxt.IntTy);
   result.addConst();
   return result;
 }
 
-TEST_F(TestClangASTContext, TestGetTypeClassDeclType) {
+TEST_F(TestTypeSystemClang, TestGetTypeClassDeclType) {
   clang::ASTContext &ctxt = m_ast->getASTContext();
   auto *nullptr_expr = new (ctxt) CXXNullPtrLiteralExpr(ctxt.NullPtrTy, SourceLocation());
   QualType t = ctxt.getDecltypeType(nullptr_expr, makeConstInt(ctxt));
   EXPECT_EQ(lldb::eTypeClassBuiltin, m_ast->GetTypeClass(t.getAsOpaquePtr()));
 }
 
-TEST_F(TestClangASTContext, TestGetTypeClassTypeOf) {
+TEST_F(TestTypeSystemClang, TestGetTypeClassTypeOf) {
   clang::ASTContext &ctxt = m_ast->getASTContext();
   QualType t = ctxt.getTypeOfType(makeConstInt(ctxt));
   EXPECT_EQ(lldb::eTypeClassBuiltin, m_ast->GetTypeClass(t.getAsOpaquePtr()));
 }
 
-TEST_F(TestClangASTContext, TestGetTypeClassTypeOfExpr) {
+TEST_F(TestTypeSystemClang, TestGetTypeClassTypeOfExpr) {
   clang::ASTContext &ctxt = m_ast->getASTContext();
   auto *nullptr_expr = new (ctxt) CXXNullPtrLiteralExpr(ctxt.NullPtrTy, SourceLocation());
   QualType t = ctxt.getTypeOfExprType(nullptr_expr);
   EXPECT_EQ(lldb::eTypeClassBuiltin, m_ast->GetTypeClass(t.getAsOpaquePtr()));
 }
 
-TEST_F(TestClangASTContext, TestGetTypeClassNested) {
+TEST_F(TestTypeSystemClang, TestGetTypeClassNested) {
   clang::ASTContext &ctxt = m_ast->getASTContext();
   QualType t_base = ctxt.getTypeOfType(makeConstInt(ctxt));
   QualType t = ctxt.getTypeOfType(t_base);
   EXPECT_EQ(lldb::eTypeClassBuiltin, m_ast->GetTypeClass(t.getAsOpaquePtr()));
 }
 
-TEST_F(TestClangASTContext, TestFunctionTemplateConstruction) {
+TEST_F(TestTypeSystemClang, TestFunctionTemplateConstruction) {
   // Tests creating a function template.
 
   CompilerType int_type = m_ast->GetBasicType(lldb::eBasicTypeInt);
   clang::TranslationUnitDecl *TU = m_ast->GetTranslationUnitDecl();
 
   // Prepare the declarations/types we need for the template.
   CompilerType clang_type =
       m_ast->CreateFunctionType(int_type, nullptr, 0U, false, 0U);
   FunctionDecl *func =
       m_ast->CreateFunctionDeclaration(TU, "foo", clang_type, 0, false);
-  ClangASTContext::TemplateParameterInfos empty_params;
+  TypeSystemClang::TemplateParameterInfos empty_params;
 
   // Create the actual function template.
   clang::FunctionTemplateDecl *func_template =
       m_ast->CreateFunctionTemplateDecl(TU, func, "foo", empty_params);
 
   EXPECT_EQ(TU, func_template->getDeclContext());
   EXPECT_EQ("foo", func_template->getName());
   EXPECT_EQ(clang::AccessSpecifier::AS_none, func_template->getAccess());
 }
 
-TEST_F(TestClangASTContext, TestFunctionTemplateInRecordConstruction) {
+TEST_F(TestTypeSystemClang, TestFunctionTemplateInRecordConstruction) {
   // Tests creating a function template inside a record.
 
   CompilerType int_type = m_ast->GetBasicType(lldb::eBasicTypeInt);
   clang::TranslationUnitDecl *TU = m_ast->GetTranslationUnitDecl();
 
   // Create a record we can put the function template int.
   CompilerType record_type =
       clang_utils::createRecordWithField(*m_ast, "record", int_type, "field");
   clang::TagDecl *record = ClangUtil::GetAsTagDecl(record_type);
 
   // Prepare the declarations/types we need for the template.
   CompilerType clang_type =
       m_ast->CreateFunctionType(int_type, nullptr, 0U, false, 0U);
   // We create the FunctionDecl for the template in the TU DeclContext because:
   // 1. FunctionDecls can't be in a Record (only CXXMethodDecls can).
   // 2. It is mirroring the behavior of DWARFASTParserClang::ParseSubroutine.
   FunctionDecl *func =
       m_ast->CreateFunctionDeclaration(TU, "foo", clang_type, 0, false);
-  ClangASTContext::TemplateParameterInfos empty_params;
+  TypeSystemClang::TemplateParameterInfos empty_params;
 
   // Create the actual function template.
   clang::FunctionTemplateDecl *func_template =
       m_ast->CreateFunctionTemplateDecl(record, func, "foo", empty_params);
 
   EXPECT_EQ(record, func_template->getDeclContext());
   EXPECT_EQ("foo", func_template->getName());
   EXPECT_EQ(clang::AccessSpecifier::AS_public, func_template->getAccess());
 }
 
-TEST_F(TestClangASTContext, TestDeletingImplicitCopyCstrDueToMoveCStr) {
+TEST_F(TestTypeSystemClang, TestDeletingImplicitCopyCstrDueToMoveCStr) {
   // We need to simulate this behavior in our AST that we construct as we don't
   // have a Sema instance that can do this for us:
   // C++11 [class.copy]p7, p18:
   //  If the class definition declares a move constructor or move assignment
   //  operator, an implicitly declared copy constructor or copy assignment
   //  operator is defined as deleted.
 
   // Create a record and start defining it.
TEST_F(TestTypeSystemClang, TestDeletingImplicitCopyCstrDueToMoveCStr) {
   // the Decl passes through Sema which will actually compute this field.
   // Instead we check that there is no copy constructor declared by the user
   // which only leaves a non-deleted defaulted copy constructor as an option
   // that our record will have no simple copy constructor.
   EXPECT_FALSE(record->hasUserDeclaredCopyConstructor());
   EXPECT_FALSE(record->hasSimpleCopyConstructor());
 }
 
-TEST_F(TestClangASTContext, TestNotDeletingUserCopyCstrDueToMoveCStr) {
+TEST_F(TestTypeSystemClang, TestNotDeletingUserCopyCstrDueToMoveCStr) {
   // Tests that we don't delete the a user-defined copy constructor when
   // a move constructor is provided.
   // See also the TestDeletingImplicitCopyCstrDueToMoveCStr test.
   llvm::StringRef class_name = "S";
   CompilerType t = clang_utils::createRecord(*m_ast, class_name);
   m_ast->StartTagDeclarationDefinition(t);
 
   CompilerType return_type = m_ast->GetBasicType(lldb::eBasicTypeVoid);

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

 #include "lldb/Host/HostInfo.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 class DWARFASTParserClangTests : public testing::Test {
-  SubsystemRAII<FileSystem, HostInfo, ClangASTContext> subsystems;
+  SubsystemRAII<FileSystem, HostInfo, TypeSystemClang> subsystems;
 };
 
 namespace {
 class DWARFASTParserClangStub : public DWARFASTParserClang {
 public:
   using DWARFASTParserClang::DWARFASTParserClang;
   using DWARFASTParserClang::LinkDeclContextToDIE;
 
   std::vector<const clang::DeclContext *> GetDeclContextToDIEMapKeys() {
     std::vector<const clang::DeclContext *> keys;
     for (const auto &it : m_decl_ctx_to_die)
       keys.push_back(it.first);
     return keys;
   }
 };
 } // namespace
 
 // If your implementation needs to dereference the dummy pointers we are
 // defining here, causing this test to fail, feel free to delete it.
 TEST_F(DWARFASTParserClangTests,
        EnsureAllDIEsInDeclContextHaveBeenParsedParsesOnlyMatchingEntries) {
-  ClangASTContext ast_ctx("dummy ASTContext", HostInfoBase::GetTargetTriple());
+  TypeSystemClang ast_ctx("dummy ASTContext", HostInfoBase::GetTargetTriple());
   DWARFASTParserClangStub ast_parser(ast_ctx);
 
   DWARFUnit *unit = nullptr;
   std::vector<DWARFDIE> dies = {DWARFDIE(unit, (DWARFDebugInfoEntry *)1LL),
                                 DWARFDIE(unit, (DWARFDebugInfoEntry *)2LL),
                                 DWARFDIE(unit, (DWARFDebugInfoEntry *)3LL),
                                 DWARFDIE(unit, (DWARFDebugInfoEntry *)4LL)};
   std::vector<clang::DeclContext *> decl_ctxs = {

lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

 #include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
 #include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataEncoder.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StreamString.h"
 
 
 
 using namespace lldb;
 using namespace lldb_private;
 
 class SymbolFileDWARFTests : public testing::Test {
   SubsystemRAII<FileSystem, HostInfo, ObjectFilePECOFF, SymbolFileDWARF,
-                ClangASTContext, SymbolFilePDB>
+                TypeSystemClang, SymbolFilePDB>
       subsystems;
 
 public:
   void SetUp() override {
     m_dwarf_test_exe = GetInputFilePath("test-dwarf.exe");
   }
 
 protected:

lldb/unittests/SymbolFile/PDB/SymbolFilePDBTests.cpp

 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/windows.h"

 #if defined(_WIN32)
     ::CoInitializeEx(nullptr, COINIT_MULTITHREADED);
 #endif
 
     FileSystem::Initialize();
     HostInfo::Initialize();
     ObjectFilePECOFF::Initialize();
     SymbolFileDWARF::Initialize();
-    ClangASTContext::Initialize();
+    TypeSystemClang::Initialize();
     SymbolFilePDB::Initialize();
 
     m_pdb_test_exe = GetInputFilePath("test-pdb.exe");
     m_types_test_exe = GetInputFilePath("test-pdb-types.exe");
   }
 
   void TearDown() override {
     SymbolFilePDB::Terminate();
-    ClangASTContext::Initialize();
+    TypeSystemClang::Initialize();
     SymbolFileDWARF::Terminate();
     ObjectFilePECOFF::Terminate();
     HostInfo::Terminate();
     FileSystem::Terminate();
 
 #if defined(_WIN32)
     ::CoUninitialize();
 #endif
TEST_F(SymbolFilePDBTests, TestSimpleClassTypes) {
   llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
   llvm::DenseSet<SymbolFile *> searched_files;
   TypeMap results;
   symfile->FindTypes(ConstString("Class"), nullptr, 0, searched_files, results);
   EXPECT_EQ(1u, results.GetSize());
   lldb::TypeSP udt_type = results.GetTypeAtIndex(0);
   EXPECT_EQ(ConstString("Class"), udt_type->GetName());
   CompilerType compiler_type = udt_type->GetForwardCompilerType();
-  EXPECT_TRUE(ClangASTContext::IsClassType(compiler_type.GetOpaqueQualType()));
+  EXPECT_TRUE(TypeSystemClang::IsClassType(compiler_type.GetOpaqueQualType()));
   EXPECT_EQ(GetGlobalConstantInteger(session, "sizeof_Class"),
             udt_type->GetByteSize());
 }
 
 TEST_F(SymbolFilePDBTests, TestNestedClassTypes) {
   FileSpec fspec(m_types_test_exe);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolFilePDB *symfile =
       static_cast<SymbolFilePDB *>(module->GetSymbolFile());
   llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
   llvm::DenseSet<SymbolFile *> searched_files;
   TypeMap results;
 
   auto clang_ast_ctx_or_err =
       symfile->GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   ASSERT_THAT_EXPECTED(clang_ast_ctx_or_err, llvm::Succeeded());
 
   auto clang_ast_ctx =
-      llvm::dyn_cast_or_null<ClangASTContext>(&clang_ast_ctx_or_err.get());
+      llvm::dyn_cast_or_null<TypeSystemClang>(&clang_ast_ctx_or_err.get());
   EXPECT_NE(nullptr, clang_ast_ctx);
 
   symfile->FindTypes(ConstString("Class"), nullptr, 0, searched_files, results);
   EXPECT_EQ(1u, results.GetSize());
 
   auto Class = results.GetTypeAtIndex(0);
   EXPECT_TRUE(Class);
   EXPECT_TRUE(Class->IsValidType());
TEST_F(SymbolFilePDBTests, TestNestedClassTypes) {
   symfile->FindTypes(ConstString("NestedClass"), &ClassCompilerDeclCtx, 0,
                      searched_files, more_results);
   EXPECT_LE(1u, more_results.GetSize());
 
   lldb::TypeSP udt_type = more_results.GetTypeAtIndex(0);
   EXPECT_EQ(ConstString("NestedClass"), udt_type->GetName());
 
   CompilerType compiler_type = udt_type->GetForwardCompilerType();
-  EXPECT_TRUE(ClangASTContext::IsClassType(compiler_type.GetOpaqueQualType()));
+  EXPECT_TRUE(TypeSystemClang::IsClassType(compiler_type.GetOpaqueQualType()));
 
   EXPECT_EQ(GetGlobalConstantInteger(session, "sizeof_NestedClass"),
             udt_type->GetByteSize());
 }
 
 TEST_F(SymbolFilePDBTests, TestClassInNamespace) {
   FileSpec fspec(m_types_test_exe);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolFilePDB *symfile =
       static_cast<SymbolFilePDB *>(module->GetSymbolFile());
   llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
   llvm::DenseSet<SymbolFile *> searched_files;
   TypeMap results;
 
   auto clang_ast_ctx_or_err =
       symfile->GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   ASSERT_THAT_EXPECTED(clang_ast_ctx_or_err, llvm::Succeeded());
 
   auto clang_ast_ctx =
-      llvm::dyn_cast_or_null<ClangASTContext>(&clang_ast_ctx_or_err.get());
+      llvm::dyn_cast_or_null<TypeSystemClang>(&clang_ast_ctx_or_err.get());
   EXPECT_NE(nullptr, clang_ast_ctx);
 
   clang::ASTContext &ast_ctx = clang_ast_ctx->getASTContext();
 
   auto tu = ast_ctx.getTranslationUnitDecl();
   EXPECT_NE(nullptr, tu);
 
   symfile->ParseDeclsForContext(CompilerDeclContext(
       clang_ast_ctx, static_cast<clang::DeclContext *>(tu)));
 
   auto ns_namespace = symfile->FindNamespace(ConstString("NS"), nullptr);
   EXPECT_TRUE(ns_namespace.IsValid());
 
   symfile->FindTypes(ConstString("NSClass"), &ns_namespace, 0, searched_files,
                      results);
   EXPECT_EQ(1u, results.GetSize());
 
   lldb::TypeSP udt_type = results.GetTypeAtIndex(0);
   EXPECT_EQ(ConstString("NSClass"), udt_type->GetName());
 
   CompilerType compiler_type = udt_type->GetForwardCompilerType();
-  EXPECT_TRUE(ClangASTContext::IsClassType(compiler_type.GetOpaqueQualType()));
+  EXPECT_TRUE(TypeSystemClang::IsClassType(compiler_type.GetOpaqueQualType()));
 
   EXPECT_EQ(GetGlobalConstantInteger(session, "sizeof_NSClass"),
             udt_type->GetByteSize());
 }
 
 TEST_F(SymbolFilePDBTests, TestEnumTypes) {
   FileSpec fspec(m_types_test_exe);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolFilePDB *symfile =
       static_cast<SymbolFilePDB *>(module->GetSymbolFile());
   llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
   llvm::DenseSet<SymbolFile *> searched_files;
   const char *EnumsToCheck[] = {"Enum", "ShortEnum"};
   for (auto Enum : EnumsToCheck) {
     TypeMap results;
     symfile->FindTypes(ConstString(Enum), nullptr, 0, searched_files, results);
     EXPECT_EQ(1u, results.GetSize());
     lldb::TypeSP enum_type = results.GetTypeAtIndex(0);
     EXPECT_EQ(ConstString(Enum), enum_type->GetName());
     CompilerType compiler_type = enum_type->GetFullCompilerType();
-    EXPECT_TRUE(ClangASTContext::IsEnumType(compiler_type.GetOpaqueQualType()));
-    clang::EnumDecl *enum_decl = ClangASTContext::GetAsEnumDecl(compiler_type);
+    EXPECT_TRUE(TypeSystemClang::IsEnumType(compiler_type.GetOpaqueQualType()));
+    clang::EnumDecl *enum_decl = TypeSystemClang::GetAsEnumDecl(compiler_type);
     EXPECT_NE(nullptr, enum_decl);
     EXPECT_EQ(2, std::distance(enum_decl->enumerator_begin(),
                                enum_decl->enumerator_end()));
 
     std::string sizeof_var = "sizeof_";
     sizeof_var.append(Enum);
     EXPECT_EQ(GetGlobalConstantInteger(session, sizeof_var),
               enum_type->GetByteSize());
TEST_F(SymbolFilePDBTests, TestTypedefs) {
   for (auto Typedef : TypedefsToCheck) {
     TypeMap results;
     symfile->FindTypes(ConstString(Typedef), nullptr, 0, searched_files,
                        results);
     EXPECT_EQ(1u, results.GetSize());
     lldb::TypeSP typedef_type = results.GetTypeAtIndex(0);
     EXPECT_EQ(ConstString(Typedef), typedef_type->GetName());
     CompilerType compiler_type = typedef_type->GetFullCompilerType();
-    ClangASTContext *clang_type_system =
-        llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem());
+    TypeSystemClang *clang_type_system =
+        llvm::dyn_cast_or_null<TypeSystemClang>(compiler_type.GetTypeSystem());
     EXPECT_TRUE(
         clang_type_system->IsTypedefType(compiler_type.GetOpaqueQualType()));
 
     std::string sizeof_var = "sizeof_";
     sizeof_var.append(Typedef);
     EXPECT_EQ(GetGlobalConstantInteger(session, sizeof_var),
               typedef_type->GetByteSize());
   }

lldb/unittests/TestingSupport/Symbol/ClangTestUtils.h

 //===- ClangTestUtils.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 LLDB_UNITTESTS_TESTINGSUPPORT_SYMBOL_CLANGTESTUTILS_H
 #define LLDB_UNITTESTS_TESTINGSUPPORT_SYMBOL_CLANGTESTUTILS_H
 
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystemClang.h"
 #include "lldb/Symbol/ClangUtil.h"
 
 namespace lldb_private {
 namespace clang_utils {
-inline clang::DeclarationName getDeclarationName(ClangASTContext &ast,
+inline clang::DeclarationName getDeclarationName(TypeSystemClang &ast,
                                                  llvm::StringRef name) {
   clang::IdentifierInfo &II = ast.getASTContext().Idents.get(name);
   return ast.getASTContext().DeclarationNames.getIdentifier(&II);
 }
 
-inline std::unique_ptr<ClangASTContext> createAST() {
-  return std::make_unique<ClangASTContext>("test ASTContext",
+inline std::unique_ptr<TypeSystemClang> createAST() {
+  return std::make_unique<TypeSystemClang>("test ASTContext",
                                            HostInfo::GetTargetTriple());
 }
 
-inline CompilerType createRecord(ClangASTContext &ast, llvm::StringRef name) {
+inline CompilerType createRecord(TypeSystemClang &ast, llvm::StringRef name) {
   return ast.CreateRecordType(ast.getASTContext().getTranslationUnitDecl(),
                               lldb::AccessType::eAccessPublic, name, 0,
                               lldb::LanguageType::eLanguageTypeC);
 }
 
 /// Create a record with the given name and a field with the given type
 /// and name.
-inline CompilerType createRecordWithField(ClangASTContext &ast,
+inline CompilerType createRecordWithField(TypeSystemClang &ast,
                                           llvm::StringRef record_name,
                                           CompilerType field_type,
                                           llvm::StringRef field_name) {
   CompilerType t = createRecord(ast, record_name);
 
-  ClangASTContext::StartTagDeclarationDefinition(t);
+  TypeSystemClang::StartTagDeclarationDefinition(t);
   ast.AddFieldToRecordType(t, field_name, field_type,
                            lldb::AccessType::eAccessPublic, 7);
-  ClangASTContext::CompleteTagDeclarationDefinition(t);
+  TypeSystemClang::CompleteTagDeclarationDefinition(t);
 
   return t;
 }
 
-/// Constructs a ClangASTContext that contains a single RecordDecl that contains
+/// Constructs a TypeSystemClang that contains a single RecordDecl that contains
 /// a single FieldDecl. Utility class as this setup is a common starting point
 /// for unit test that exercise the ASTImporter.
 struct SourceASTWithRecord {
-  std::unique_ptr<ClangASTContext> ast;
+  std::unique_ptr<TypeSystemClang> ast;
   CompilerType record_type;
   clang::RecordDecl *record_decl = nullptr;
   clang::FieldDecl *field_decl = nullptr;
   SourceASTWithRecord() {
     ast = createAST();
     record_type = createRecordWithField(
         *ast, "Source", ast->GetBasicType(lldb::BasicType::eBasicTypeChar),
         "a_field");