Move some functions from ClangASTContext to ClangUtil

[zturner]

Summary

This is pretty mechanical, so you don't really have to look at this in too much detail. I'm mostly posting it here to make sure people are ok with the high level idea. Basically ClangASTContext is a monstrous file and I want to reduce the size by splitting out some of the functionality. There's a ton of functions in ClangASTContext that are static and are basically helper functions, but then other people like DWARFASTParserClang, or ClangASTImporter, or other places re-use those functions. So the idea is just to move all these common clang helper functions into a single place.

In doing so, it makes testing this type of functionality very easy, because you can write a unit test for every function in the file. I did that in this patch, and actually found one bug as a result of my unittest failing (yay for unit tests). Since that is the only functional change in the patch, you may want to look at it specifically. It's ClangUtil::RemoveFastQualifiers. The version before my patch did nothing, it returned exactly the same value it was passed in, because QualType::getQualifiers() returns a clang::Qualifiers by value, so it was not modifying the QualType's qualifiers, but a copy of them, which was immediately discarded.

If anyone can think of a way to exercise this in a public API test, let me know.

I'm hoping to gradually move some more of the ClangASTContext functions over to ClangUtil in subsequent patches. It makes understanding the important parts of ClangASTContext easier, and it will allow me to add more unittests for the rest of the functions as well (hopefully turning up more bugs).

[zturner]

Any issues with this? Honestly you can probably just read the description
and lgtm it based on that, because as I said it's 99% a code move, and
there is no functional change except for the one bug fix in
ClangUtil::RemoveFastQualifiers.

I have a followup patch almost complete which moves some more function, and
adds some more unit tests, and (so far) fixes 2 more bugs that were found
as a result of the unit tests. So I think the work is a win just on the
grounds that I've already found 3 bugs as a result, even disregarding the
benefits to ClangASTContext in file size.

Let me know if I can continue this effort without review, it would save all
of us some time and obviously I can use my judgement if I think the change
is non-trivial.

[clayborg]

The main reason I don't like this is all of the merge headaches it will create for us. We merge to swift.org and then over into some internal git repos. We have like 5 branches that we are always propagating things over to. This kind of change looks good in top of tree, but causes a ton if issues down the line. So this is my main hesitation. If we could keep any functions that were in ClangASTContext in ClangASTContext, because that is where they really belong. I don't really like the ClangUtil.cpp file because it is actually doing clang::ASTContext related things so the functions actually belong in ClangASTContext from a design point of view. So I would rather see the ClangUtil.cpp file go away and have everything be back in ClangASTContext.cpp.

[clayborg]

I do like the tests that you added and I think we can still do the tests in TestClangASTContext.cpp.

[zturner]

One or two of the functions, you are right. They do clang::ASTContext related things. That was actually an oversight on my part. I meant to move only functions that specifically did NOT do clang::ASTContext things. Like RemoveFastQualifiers, or converting enums, or converting from qual types to canonical qual types. Very simple utility functions.

The reason why I don't think they should be in ClangASTContext from a design point of view is because they are used from all over the places, including from places that aren't actually holding and don't need an ASTContext.

What if I move the clang::ASTContext functions back but keep the truly independent ones here? ClangASTContext is a really egregiously oversized file, so I think splitting it up a bit would be helpful. I also find it helpful to break a lot of these cyclic dependencies, where A.cpp includes B.h and B.cpp includes A.h, and we're doing that all over the place in large part because B.cpp is ClangASTContext and A.cpp is anything else that has to do anything, no matter what it is, to a clang type, even if it doesn't need an ASTContext.

What kind of merge conflict does it create? There's no tricky changes here, why wouldn't they be mergeable to the other branch? I'm not really crazy about the idea of having decisions about upstream being based on someone's downstream issues though :-/ If something is good for the upstream it seems like that's merit enough to get it in.

[clayborg]

In D18530#387175, @zturner wrote:

One or two of the functions, you are right. They do clang::ASTContext related things. That was actually an oversight on my part. I meant to move only functions that specifically did NOT do clang::ASTContext things. Like RemoveFastQualifiers, or converting enums, or converting from qual types to canonical qual types. Very simple utility functions.

They are still clang::ASTContext related things since clang::QualType is part of that whole infrastructure.

The reason why I don't think they should be in ClangASTContext from a design point of view is because they are used from all over the places, including from places that aren't actually holding and don't need an ASTContext.

Does it just come down to QualType stuff? Those are fine the exist in ClangUtil.cpp, but again, we have a ton or merges we are doing daily and any moving of code does cause merge conflicts when they are just moved to be logically moved elsewhere. When we have a fix, it first goes into llvm.org SVN, then we cherry pick it over to swift.org into two branches: master and master-next, then we cherry pick these fixes over to our internal branches where we at least have two more merges. Each merge is possibly going into older code where we would not have ClangUtil.cpp in that branch. So then we need to be very careful with our merges to make sure we do them right. We finally got to a place after splitting using DWARFASTParser and all that where merges are going very smoothy most of the time since anything language specific is off in a separate file.

What if I move the clang::ASTContext functions back but keep the truly independent ones here? ClangASTContext is a really egregiously oversized file, so I think splitting it up a bit would be helpful. I also find it helpful to break a lot of these cyclic dependencies, where A.cpp includes B.h and B.cpp includes A.h, and we're doing that all over the place in large part because B.cpp is ClangASTContext and A.cpp is anything else that has to do anything, no matter what it is, to a clang type, even if it doesn't need an ASTContext.

We can probably simplify our header includes. The only time you need to include a header file is if it affects the layout of the class in question. That means base classes and instance variables only. Any functions that take full fledged types like:

class Bar
{
    void Foo(lldb_private::FileSpec file_spec);
};

Doesn't require FileSpec.h, just a forward declaration of FileSpec, because it doesn't affect the layout of the class. Anyone that includes the above header might need to manually include "FileSpec.h", but we can probably simplify our includes quite a bit, so that might help.

So again, moving anything can cause merging headaches. See below for more details.

What kind of merge conflict does it create? There's no tricky changes here, why wouldn't they be mergeable to the other branch? I'm not really crazy about the idea of having decisions about upstream being based on someone's downstream issues though :-/ If something is good for the upstream it seems like that's merit enough to get it in.

So one example is the RemoveFastQualifiers() fix. If we merge that back into a branch that doesn't have ClangUtil.cpp, we need to take the contents from any functions in ClangUtils.cpp and find the old corresponding functions and paste the new code back into there.

So if we only had private branches at Apple I wouldn't be making this argument. But on swift.org, we have public merges going on all the time with auto mergers. They can often fail when we do things like this (move stuff for organization sake), so then we have to manually intervene. There are 3 branches on swift.org that are always merging from other places. The LLVM and Clang on swift.org doesn't track top of tree SVN llvm and clang, but might be up to two months behind.

So I really implore us to not make these kinds of disruptive changes as it ends up causing our automation steps to fail and causes us to have to manually intervene and spend a lot of time doing manual merges.

[zturner]

But wouldn't doing that manual merge once then make things easier for the future? For example, if you merge back to a branch that doesn't have ClangUtil.cpp, and then you just add ClangUtil.cpp to that branch, the problem is solved for the future. So while it's an annoying manual merge, it only has to happen once.
Incidentally, splitting up code like this makes merges easier over the long run, just like the example you gave with DWARFASTParserClang where now language specific stuff is in its own file.

idk, I just don't feel very good about starting from the premise that code re-organizations are discouraged because of X, where X is, well pretty much anything. It's impossible for everyone to know about all the issues that all the downstream customers have to deal with, and in principle I feel like changes such as this should even be able to go through without review because the technical merits of having a healthy code organization are well understood, and while discouraging code re-organization might make one particular customer's life easier, I think it weighs on the larger project and indirectly every other downstream customer as a result.

I'm curious now what clang does in this regard, so +rsmith in case he has some insight into what happens in clang when someone wants to re-organize some code and how other downstream customers (for example, swift) deal with this.

Just to be clear, I'm genuinely sympathetic to the issues other people have to face with regards to their downstream build issues, so if there's any way for me to make this less painful I will go out of my way and spend extra time to make it so. But I think we should only be discussing the technical merits of the design and whether the code organization.

[clayborg]

I have explained my beef with the changes. If you feel you must make them as you want to we will deal with the fallout and extra work.

[tberghammer]

I don't maintain any downstream branch to worry about merges but my personal opinion is moving large amount of code around can cause some issue in the future even for upstream. The 2 main issue I can think about:

• "git log" and "git blame" will not display the original change for the code what is problematic when we try to track down why a piece of code have been added (especially for special cases)
• As an active LLDB developer I have a pretty good idea about where a given piece of code lives. Moving the code around invalidates this knowledge for every developer in the project

So in general if we get some actual advantage from moving the code (e.g. cleaner API, better testing options, etc...) then I have no issue around it but if the only gain is the file size reduction and the removal of the cyclic dependencies then I think this causes more problem then the benefit of the change (same reason why we don't run clang-format over the full code base).

In this concrete case I don't see the benefit neither in the API nor for testing as all functions were accessible before in the same way and the tests can call the functions from the ClangASTContext instead of the ClangUtils with the same functionality.

[rsmith]

In D18530#387230, @zturner wrote:

I'm curious now what clang does in this regard, so +rsmith in case he has some insight into what happens in clang when someone wants to re-organize some code and how other downstream customers (for example, swift) deal with this.

Clang has no API stability guarantees for its C++ interface. We reserve the right to reorganize at will, and to update, rename, and remove interfaces. This applies doubly to our internal code organization. Yes, this creates a burden on people maintaining out-of-tree patches, but in some ways that's a benefit, as it encourages patches to be contributed upstream when they make sense, or at least for patches to be proposed to refactor upstream so that the local changes are cleanly separable from the upstream code.

Organizational changes do have a cost to upstream development in many ways (people are no longer familiar with the code organization, merging fixes to point releases is harder, work-in-progress changes may need non-trivial work to rebase, ...), so we'd only make them when they make sense from a technical / organizational perspective, but in the long term, it's not possible to maintain a healthy codebase if cleanup changes are held back due to those short-term costs.

[zturner]

In D18530#387328, @tberghammer wrote:

I don't maintain any downstream branch to worry about merges but my personal opinion is moving large amount of code around can cause some issue in the future even for upstream. The 2 main issue I can think about:

• "git log" and "git blame" will not display the original change for the code what is problematic when we try to track down why a piece of code have been added (especially for special cases)
• As an active LLDB developer I have a pretty good idea about where a given piece of code lives. Moving the code around invalidates this knowledge for every developer in the project

So in general if we get some actual advantage from moving the code (e.g. cleaner API, better testing options, etc...) then I have no issue around it but if the only gain is the file size reduction and the removal of the cyclic dependencies then I think this causes more problem then the benefit of the change (same reason why we don't run clang-format over the full code base).

In this concrete case I don't see the benefit neither in the API nor for testing as all functions were accessible before in the same way and the tests can call the functions from the ClangASTContext instead of the ClangUtils with the same functionality.

In this case I only moved a few functions just to test the waters, but if you look through ClangASTContext.h there are probably 40-50 functions that could theory be moved under the same idea. It's a couple thousand lines of code of jsut generic helper functions, which is not insignificant.

The corollary to your statement is that we can just keep adding everything clang related to this one file, which if so maybe it jumps from 10,000 lines to 20,000 lines. File size is not normally a major concern, but at the same time I don't think we should just allow files and classes to grow unbounded in lines of code and number of member functions without being willing to think about if there should be a split.

But relevant code should be grouped together as much as possible. Small interfaces are easier to understand than big interfaces. Answering the question "is there a way to do X" is easier when you only have to look an interface containing 30 functions than when you have to look through an interface containing 200 functions.

As for "git log", "git blame", and knowing where a piece of code lives, there will always be times where you have to do some code archaeology to trace a line of code back to its origin. It's usually only a few extra commands. For example, you git blame ClangUtil.cpp, the revision of a line is the first commit of that file. The diff (or the commit message) shows it was moved from ClangASTContext.cpp. So you git blame the corresponding lines of ClangASTContext.cpp starting with x~1 where x is the revision shown in the first diff. It doesn't really much extra effort at all, certainly not so much that the extra effort outweighs the benefits of maintaining healthy code.

Just my 2c, if nobody likes the idea then so be it, but I think it's easy to get stuck viewing this from the lens of someone who's already spent a great deal of effort understanding the code. So I would encourage you to think about it from the viewpoint of a newcomer to the codebase trying to understand the code.

[zturner]

So, in thinking about this some more, my end goal does not necessarily involve the creation of a new file. The primary goal is group related functions together into a more bite-sized interface in order to make it easier to understand the code.

How about keeping everything in the same file, but still splitting these functions out into another class defined in that file? For example, the ClangUtil class could still be in ClangASTContext.h. I think that eliminates the concern about merging, and while it doesn't address the issue of the massive file (which I still think is an important consideration for the long term health of this code), it at least makes some progress in that it groups everything together so that it makes the interface more easily digestible, and makes a move to another file easier in the future if someone wanted to do it.

[clayborg]

In D18530#387377, @zturner wrote:

So, in thinking about this some more, my end goal does not necessarily involve the creation of a new file. The primary goal is group related functions together into a more bite-sized interface in order to make it easier to understand the code.

How about keeping everything in the same file, but still splitting these functions out into another class defined in that file? For example, the ClangUtil class could still be in ClangASTContext.h. I think that eliminates the concern about merging, and while it doesn't address the issue of the massive file (which I still think is an important consideration for the long term health of this code), it at least makes some progress in that it groups everything together so that it makes the interface more easily digestible, and makes a move to another file easier in the future if someone wanted to do it.

That still doesn't help downstream merging.

[zturner]

In D18530#387382, @clayborg wrote:

In D18530#387377, @zturner wrote:

So, in thinking about this some more, my end goal does not necessarily involve the creation of a new file. The primary goal is group related functions together into a more bite-sized interface in order to make it easier to understand the code.

How about keeping everything in the same file, but still splitting these functions out into another class defined in that file? For example, the ClangUtil class could still be in ClangASTContext.h. I think that eliminates the concern about merging, and while it doesn't address the issue of the massive file (which I still think is an important consideration for the long term health of this code), it at least makes some progress in that it groups everything together so that it makes the interface more easily digestible, and makes a move to another file easier in the future if someone wanted to do it.

That still doesn't help downstream merging.

I thought you said the issue was if you try to merge to a branch that didn't have the ClangUtil.cpp file. If you just copy and paste a function from one location in a file to another location and change the class it belongs to, that's still a problem?

That's a mighty big burden for upstream developers to have to deal with.

[zturner]

The last time we talked about this, you said something along the lines of "Changes to LLVM and LLDB at the same time are a problem, but any refactor that happens entirely within LLDB is fine"

[clayborg]

I thought you said the issue was if you try to merge to a branch that didn't have the ClangUtil.cpp file. If you just copy and paste a function from one location in a file to another location and change the class it belongs to, that's still a problem?

So merging to current top of tree is easier than merging to a release branch. When merging to a top of tree for any repository that is currently mirroring a close relative of the current code is easy and the extra file doesn't matter. The issues arise when we find a bug deep in one of our released branches. Then to fix it we actually fix it into llvm.org SVN, then merge to swift.org into many branches, and then merge into many internal branches and eventually over to the release branch. We want minimal code changes so that we minimize our risk when taking fixes into release branches.

Anytime we introduce manual merging where we have to say "Oh, this function in 'ClangUtil::DoSomething' used to be in 'ClangASTContext::DoSomething', so I will need to take the guts of the function and manually copy it over and make sure it actually works". This is when errors happen. The other worse case is where we actually just merge the ClangUtil.cpp and ClangUtil.h file into our older branch, make sure it gets built in the Xcode project file, and then none of our code gets fixed because we still have the "ClangASTContext::DoSomething" that is buggy, but our merging worked just fine by merging in a new source that compiles but no one uses.

That's a mighty big burden for upstream developers to have to deal with.

But it is where we are and it is our reality. So I am trying to minimize and point out when these kinds of issues will cause problems as I review patches. I know it is tempting to move stuff around, and we used to just accept these patches, but as we have over the past year, we have run into many issues of exactly the flavor we are talking about here, so I am proactively trying to avoid it when the need to do so isn't as strong. Many times I agree that things were architected incorrectly, or just are architected the way they are because of the way the code has evolved over the years, and those I believe we should fix. I would rather avoid this when we can when there isn't a strong reason to do so. I believe this is one of those cases.

[zturner]

I will move most of this back to ClangASTContext, but I want to state again that I would like to reach a point where downstream merge issues are not even a topic that comes up in code reviews. I see many huge refactors coming through from people that do not go up for review, do not ask about other peoples' downstream build issues or how it affects them, and are not discussed in the open before going through.

So I do not want there to be a double standard. Either everyone needs to run every change by everyone in the community before committing anything, or we adopt the LLVM policy of post commit review and downstream maintainers handling their downstream problems silently.

It is not fair to even mention the issue of downstream merge issues, because it stifles improvements to code health (even if they are minor improvements), when LLVM has a clear policy that downstream problems are not the upstream's problem. I'm fine working together and compromising or whatever, but I am pretty strongly opposed to rejecting changes that improve code health because of someone's merge problems. That needs to be an issue that is dealt with downstream -- and more importantly not even mentioned as a point of discussion in the upstream.

With that said, I will undo most of these changes (but continue writing the unittests)

[labath]

Cyclic code dependencies are not an imaginary problem. Right now, it is very hard to make lldb-server small, because everything in lldb depends on everything else, and so lldb-server ends up containing chunks e.g. clang, even though that code will never get execute, because it is impossible to remove it without causing link errors. So, I welcome anything which makes this task easier, now or in the future. Breaking things up into smaller classes/files is definitely one of those things. I also welcome more unittests.

include/lldb/Symbol/ClangASTContext.h

public:
     bool
     HasExternalSource ();
 
     void
     SetExternalSource (llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> &ast_source_ap);
 
     void
     RemoveExternalSource ();
-    
-    bool
-    GetCompleteDecl (clang::Decl *decl)
-    {
-        return ClangASTContext::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);
-
-    static bool
-    GetCompleteDecl (clang::ASTContext *ast,
-                     clang::Decl *decl);
-
     void SetMetadataAsUserID (const void *object,
                               lldb::user_id_t user_id);
 
     void SetMetadata (const void *object,
                       ClangASTMetadata &meta_data)
     {
         SetMetadata(getASTContext(), object, meta_data);
     }
public:
     
     //------------------------------------------------------------------
     // Basic Types
     //------------------------------------------------------------------
     CompilerType
     GetBuiltinTypeForEncodingAndBitSize (lldb::Encoding encoding,
                                          size_t bit_size) override;
 
-    static CompilerType
-    GetBuiltinTypeForEncodingAndBitSize (clang::ASTContext *ast,
-                                         lldb::Encoding encoding,
-                                         uint32_t bit_size);
-
     CompilerType
     GetBasicType (lldb::BasicType type);
 
-    static CompilerType
-    GetBasicType (clang::ASTContext *ast, lldb::BasicType type);
-    
-    static CompilerType
-    GetBasicType (clang::ASTContext *ast, const ConstString &name);
-    
-    static lldb::BasicType
-    GetBasicTypeEnumeration (const ConstString &name);
-
     CompilerType
     GetBuiltinTypeForDWARFEncodingAndBitSize (
         const char *type_name,
         uint32_t dw_ate,
         uint32_t bit_size);
 
     CompilerType
     GetCStringType(bool is_const);

include/lldb/Symbol/ClangUtil.h

 //===-- ClangUtil.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 // A collection of helper methods and data structures for manipulating clang
 // types and decls.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_CLANGUTIL_H
 #define LLDB_SYMBOL_CLANGUTIL_H
 
+#include "clang/AST/ASTContext.h"
 #include "clang/AST/Type.h"
 
 #include "lldb/Symbol/CompilerType.h"
 
 namespace lldb_private
 {
 struct ClangUtil
 {
     static bool
-    IsClangType(const CompilerType &ct);
+    DeclsAreEquivalent(clang::Decl *lhs_decl, clang::Decl *rhs_decl);
 
-    static clang::QualType
-    GetQualType(const CompilerType &ct);
+    static void
+    DumpDeclContextHiearchy(clang::DeclContext *decl_ctx);
+
+    static void
+    DumpDeclHiearchy(clang::Decl *decl);
+
+    static CompilerType
+    GetBasicType(clang::ASTContext *ast, lldb::BasicType type);
+
+    static CompilerType
+    GetBasicType(clang::ASTContext *ast, const ConstString &name);
+
+    static lldb::BasicType
+    GetBasicTypeEnumeration(const ConstString &name);
+
+    static CompilerType
+    GetBuiltinTypeForEncodingAndBitSize(clang::ASTContext *ast, lldb::Encoding encoding, uint32_t bit_size);
 
     static clang::QualType
     GetCanonicalQualType(const CompilerType &ct);
 
+    static bool
+    GetCompleteDecl(clang::ASTContext *ast, clang::Decl *decl);
+
+    static lldb::opaque_compiler_type_t
+    GetOpaqueCompilerType(clang::ASTContext *ast, lldb::BasicType type);
+
+    static clang::QualType
+    GetQualType(const CompilerType &ct);
+
+    static bool
+    IsClangType(const CompilerType &ct);
+
+    static bool
+    QualTypeMatchesBitSize(const uint64_t bit_size, clang::ASTContext *ast, clang::QualType qual_type);
+
     static CompilerType
     RemoveFastQualifiers(const CompilerType &ct);
 };
 }
 
 #endif

source/API/SBTarget.cpp

 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBModuleSpec.h"
-#include "lldb/API/SBSourceManager.h"
 #include "lldb/API/SBProcess.h"
+#include "lldb/API/SBSourceManager.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBSymbolContextList.h"
 #include "lldb/Breakpoint/BreakpointID.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointList.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressResolver.h"
 #include "lldb/Core/AddressResolverName.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/RegularExpression.h"
+#include "lldb/Core/STLUtils.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Core/STLUtils.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/DeclVendor.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/LanguageRuntime.h"
if (typename_cstr && typename_cstr[0] && target_sp)
                     }
                 }
             }
         }
 
         // No matches, search for basic typename matches
         ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
         if (clang_ast)
-            return SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), const_typename));
+            return SBType(ClangUtil::GetBasicType(clang_ast->getASTContext(), const_typename));
     }
     return SBType();
 }
 
 SBType
 SBTarget::GetBasicType(lldb::BasicType type)
 {
     TargetSP target_sp(GetSP());
     if (target_sp)
     {
         ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
         if (clang_ast)
-            return SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), type));
+            return SBType(ClangUtil::GetBasicType(clang_ast->getASTContext(), type));
     }
     return SBType();
 }
 
 
 lldb::SBTypeList
 SBTarget::FindTypes (const char* typename_cstr)
 {
if (typename_cstr && typename_cstr[0] && target_sp)
             }
         }
         
         if (sb_type_list.GetSize() == 0)
         {
             // No matches, search for basic typename matches
             ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
             if (clang_ast)
-                sb_type_list.Append (SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), const_typename)));
+                sb_type_list.Append(SBType(ClangUtil::GetBasicType(clang_ast->getASTContext(), const_typename)));
         }
     }
     return sb_type_list;
 }
 
 SBValueList
 SBTarget::FindGlobalVariables (const char *name, uint32_t max_matches)
 {

source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

if (!m_ast_importer_sp->CompleteTagDecl (tag_decl))
 
                 if (!tag_type)
                     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 (!ClangUtil::DeclsAreEquivalent(tag_decl, candidate_tag_decl))
                     continue;
 
                 if (m_ast_importer_sp->CompleteTagDeclWithOrigin (tag_decl, candidate_tag_decl))
                     found = true;
             }
         }
     }
 
else
         }
 
         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);
-    
+    ClangUtil::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);
     }
ClangASTSource::layoutRecordType(const RecordDecl *record, uint64_t &size, uint64_t &alignment,
 
     if (origin_record.IsInvalid())
         return false;
 
     FieldOffsetMap origin_field_offsets;
     BaseOffsetMap origin_base_offsets;
     BaseOffsetMap origin_virtual_base_offsets;
 
-    ClangASTContext::GetCompleteDecl(&origin_record->getASTContext(), const_cast<RecordDecl*>(origin_record.decl));
+    ClangUtil::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(origin_record->getASTContext().getASTRecordLayout(origin_record.decl));
 
     int field_idx = 0, field_count = record_layout.getFieldCount();

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

 //===-- ClangExpressionDeclMap.cpp -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangExpressionDeclMap.h"
 
 #include "ASTDumper.h"
 #include "ClangASTSource.h"
 #include "ClangModulesDeclVendor.h"
 #include "ClangPersistentVariables.h"
 
-#include "clang/AST/ASTConsumer.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/AST/DeclarationName.h"
-#include "clang/AST/Decl.h"
-#include "lldb/lldb-private.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Expression/Materializer.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ClangUtil.h"
+#include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
-#include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/ObjCLanguageRuntime.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/lldb-private.h"
+#include "clang/AST/ASTConsumer.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclarationName.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace clang;
 
 namespace
ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
 
     Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
 
     if (target == NULL)
         return;
 
     ASTContext *scratch_ast_context = target->GetScratchClangASTContext()->getASTContext();
 
-    TypeFromUser user_type (ClangASTContext::GetBasicType(scratch_ast_context, eBasicTypeVoid).GetPointerType().GetLValueReferenceType());
-    TypeFromParser parser_type (ClangASTContext::GetBasicType(m_ast_context, eBasicTypeVoid).GetPointerType().GetLValueReferenceType());
+    TypeFromUser user_type(
+        ClangUtil::GetBasicType(scratch_ast_context, eBasicTypeVoid).GetPointerType().GetLValueReferenceType());
+    TypeFromParser parser_type(
+        ClangUtil::GetBasicType(m_ast_context, eBasicTypeVoid).GetPointerType().GetLValueReferenceType());
     NamedDecl *var_decl = context.AddVarDecl(parser_type);
 
     std::string decl_name(context.m_decl_name.getAsString());
     ConstString entity_name(decl_name.c_str());
     ClangExpressionVariable *entity(new ClangExpressionVariable(m_parser_vars->m_exe_ctx.GetBestExecutionContextScope (),
                                                                 entity_name,
                                                                 user_type,
                                                                 m_parser_vars->m_target_info.byte_order,

 
 void
 ClangExpressionDeclMap::AddOneRegister (NameSearchContext &context,
                                         const RegisterInfo *reg_info,
                                         unsigned int current_id)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 
-    CompilerType clang_type = ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (m_ast_context,
-                                                                                    reg_info->encoding,
-                                                                                    reg_info->byte_size * 8);
+    CompilerType clang_type =
+        ClangUtil::GetBuiltinTypeForEncodingAndBitSize(m_ast_context, reg_info->encoding, reg_info->byte_size * 8);
 
     if (!clang_type)
     {
         if (log)
             log->Printf("  Tried to add a type for %s, but couldn't get one", context.m_decl_name.getAsString().c_str());
         return;
     }
 
if (!copied_clang_type)
         if (log)
             log->Printf("ClangExpressionDeclMap::AddThisType - Couldn't import the type");
 
         return;
     }
 
     if (copied_clang_type.IsAggregateType() && copied_clang_type.GetCompleteType ())
     {
-        CompilerType void_clang_type = ClangASTContext::GetBasicType(m_ast_context, eBasicTypeVoid);
+        CompilerType void_clang_type = ClangUtil::GetBasicType(m_ast_context, eBasicTypeVoid);
         CompilerType void_ptr_clang_type = void_clang_type.GetPointerType();
 
         CompilerType method_type = ClangASTContext::CreateFunctionType (m_ast_context,
                                                                         void_clang_type,
                                                                         &void_ptr_clang_type,
                                                                         1,
                                                                         false,
                                                                         copied_clang_type.GetTypeQualifiers());

source/Symbol/ClangASTContext.cpp

 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Flags.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ThreadSafeDenseMap.h"
-#include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/VerifyDecl.h"
ClangASTContext::getTargetInfo()
     // target_triple should be something like "x86_64-apple-macosx"
     if (m_target_info_ap.get() == nullptr && !m_target_triple.empty())
         m_target_info_ap.reset (TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(), getTargetOptions()));
     return m_target_info_ap.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);
-    if (qual_type_bit_size == bit_size)
-        return true;
-    return false;
-}
-
 CompilerType
 ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (Encoding encoding, size_t bit_size)
 {
-    return ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (getASTContext(), encoding, bit_size);
-}
-
-CompilerType
-ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (ASTContext *ast, Encoding encoding, uint32_t bit_size)
-{
-    if (!ast)
-        return CompilerType();
-    switch (encoding)
-    {
-    case eEncodingInvalid:
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
-            return CompilerType (ast, ast->VoidPtrTy);
-        break;
-        
-    case eEncodingUint:
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
-            return CompilerType (ast, ast->UnsignedCharTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
-            return CompilerType (ast, ast->UnsignedShortTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
-            return CompilerType (ast, ast->UnsignedIntTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
-            return CompilerType (ast, ast->UnsignedLongTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
-            return CompilerType (ast, ast->UnsignedLongLongTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
-            return CompilerType (ast, ast->UnsignedInt128Ty);
-        break;
-        
-    case eEncodingSint:
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
-            return CompilerType (ast, ast->CharTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
-            return CompilerType (ast, ast->ShortTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
-            return CompilerType (ast, ast->IntTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
-            return CompilerType (ast, ast->LongTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
-            return CompilerType (ast, ast->LongLongTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
-            return CompilerType (ast, ast->Int128Ty);
-        break;
-        
-    case eEncodingIEEE754:
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
-            return CompilerType (ast, ast->FloatTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
-            return CompilerType (ast, ast->DoubleTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
-            return CompilerType (ast, ast->LongDoubleTy);
-        if (QualTypeMatchesBitSize (bit_size, ast, ast->HalfTy))
-            return CompilerType (ast, ast->HalfTy);
-        break;
-        
-    case eEncodingVector:
-        // Sanity check that bit_size is a multiple of 8's.
-        if (bit_size && !(bit_size & 0x7u))
-            return CompilerType (ast, ast->getExtVectorType (ast->UnsignedCharTy, bit_size/8));
-        break;
-    }
-    
-    return CompilerType();
-}
-
-
-
-lldb::BasicType
-ClangASTContext::GetBasicTypeEnumeration (const ConstString &name)
-{
-    if (name)
-    {
-        typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
-        static TypeNameToBasicTypeMap g_type_map;
-        static std::once_flag g_once_flag;
-        std::call_once(g_once_flag, [](){
-            // "void"
-            g_type_map.Append(ConstString("void").GetCString(), eBasicTypeVoid);
-            
-            // "char"
-            g_type_map.Append(ConstString("char").GetCString(), eBasicTypeChar);
-            g_type_map.Append(ConstString("signed char").GetCString(), eBasicTypeSignedChar);
-            g_type_map.Append(ConstString("unsigned char").GetCString(), eBasicTypeUnsignedChar);
-            g_type_map.Append(ConstString("wchar_t").GetCString(), eBasicTypeWChar);
-            g_type_map.Append(ConstString("signed wchar_t").GetCString(), eBasicTypeSignedWChar);
-            g_type_map.Append(ConstString("unsigned wchar_t").GetCString(), eBasicTypeUnsignedWChar);
-            // "short"
-            g_type_map.Append(ConstString("short").GetCString(), eBasicTypeShort);
-            g_type_map.Append(ConstString("short int").GetCString(), eBasicTypeShort);
-            g_type_map.Append(ConstString("unsigned short").GetCString(), eBasicTypeUnsignedShort);
-            g_type_map.Append(ConstString("unsigned short int").GetCString(), eBasicTypeUnsignedShort);
-            
-            // "int"
-            g_type_map.Append(ConstString("int").GetCString(), eBasicTypeInt);
-            g_type_map.Append(ConstString("signed int").GetCString(), eBasicTypeInt);
-            g_type_map.Append(ConstString("unsigned int").GetCString(), eBasicTypeUnsignedInt);
-            g_type_map.Append(ConstString("unsigned").GetCString(), eBasicTypeUnsignedInt);
-            
-            // "long"
-            g_type_map.Append(ConstString("long").GetCString(), eBasicTypeLong);
-            g_type_map.Append(ConstString("long int").GetCString(), eBasicTypeLong);
-            g_type_map.Append(ConstString("unsigned long").GetCString(), eBasicTypeUnsignedLong);
-            g_type_map.Append(ConstString("unsigned long int").GetCString(), eBasicTypeUnsignedLong);
-            
-            // "long long"
-            g_type_map.Append(ConstString("long long").GetCString(), eBasicTypeLongLong);
-            g_type_map.Append(ConstString("long long int").GetCString(), eBasicTypeLongLong);
-            g_type_map.Append(ConstString("unsigned long long").GetCString(), eBasicTypeUnsignedLongLong);
-            g_type_map.Append(ConstString("unsigned long long int").GetCString(), eBasicTypeUnsignedLongLong);
-            
-            // "int128"
-            g_type_map.Append(ConstString("__int128_t").GetCString(), eBasicTypeInt128);
-            g_type_map.Append(ConstString("__uint128_t").GetCString(), eBasicTypeUnsignedInt128);
-            
-            // Miscellaneous
-            g_type_map.Append(ConstString("bool").GetCString(), eBasicTypeBool);
-            g_type_map.Append(ConstString("float").GetCString(), eBasicTypeFloat);
-            g_type_map.Append(ConstString("double").GetCString(), eBasicTypeDouble);
-            g_type_map.Append(ConstString("long double").GetCString(), eBasicTypeLongDouble);
-            g_type_map.Append(ConstString("id").GetCString(), eBasicTypeObjCID);
-            g_type_map.Append(ConstString("SEL").GetCString(), eBasicTypeObjCSel);
-            g_type_map.Append(ConstString("nullptr").GetCString(), eBasicTypeNullPtr);
-            g_type_map.Sort();
-        });
-        
-        return g_type_map.Find(name.GetCString(), eBasicTypeInvalid);
-    }
-    return eBasicTypeInvalid;
-}
-
-CompilerType
-ClangASTContext::GetBasicType (ASTContext *ast, const ConstString &name)
-{
-    if (ast)
-    {
-        lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration (name);
-        return ClangASTContext::GetBasicType (ast, basic_type);
-    }
-    return CompilerType();
+    return ClangUtil::GetBuiltinTypeForEncodingAndBitSize(getASTContext(), encoding, bit_size);
 }
 
 uint32_t
 ClangASTContext::GetPointerByteSize ()
 {
     if (m_pointer_byte_size == 0)
         m_pointer_byte_size = GetBasicType(lldb::eBasicTypeVoid).GetPointerType().GetByteSize(nullptr);
     return m_pointer_byte_size;
 }
 
 CompilerType
 ClangASTContext::GetBasicType (lldb::BasicType basic_type)
 {
-    return GetBasicType (getASTContext(), basic_type);
+    return ClangUtil::GetBasicType(getASTContext(), basic_type);
 }
 
 CompilerType
-ClangASTContext::GetBasicType (ASTContext *ast, lldb::BasicType basic_type)
-{
-    if (ast)
-    {
-        lldb::opaque_compiler_type_t clang_type = nullptr;
-        
-        switch (basic_type)
-        {
-            case eBasicTypeInvalid:
-            case eBasicTypeOther:
-                break;
-            case eBasicTypeVoid:
-                clang_type = ast->VoidTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeChar:
-                clang_type = ast->CharTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeSignedChar:
-                clang_type = ast->SignedCharTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeUnsignedChar:
-                clang_type = ast->UnsignedCharTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeWChar:
-                clang_type = ast->getWCharType().getAsOpaquePtr();
-                break;
-            case eBasicTypeSignedWChar:
-                clang_type = ast->getSignedWCharType().getAsOpaquePtr();
-                break;
-            case eBasicTypeUnsignedWChar:
-                clang_type = ast->getUnsignedWCharType().getAsOpaquePtr();
-                break;
-            case eBasicTypeChar16:
-                clang_type = ast->Char16Ty.getAsOpaquePtr();
-                break;
-            case eBasicTypeChar32:
-                clang_type = ast->Char32Ty.getAsOpaquePtr();
-                break;
-            case eBasicTypeShort:
-                clang_type = ast->ShortTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeUnsignedShort:
-                clang_type = ast->UnsignedShortTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeInt:
-                clang_type = ast->IntTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeUnsignedInt:
-                clang_type = ast->UnsignedIntTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeLong:
-                clang_type = ast->LongTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeUnsignedLong:
-                clang_type = ast->UnsignedLongTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeLongLong:
-                clang_type = ast->LongLongTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeUnsignedLongLong:
-                clang_type = ast->UnsignedLongLongTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeInt128:
-                clang_type = ast->Int128Ty.getAsOpaquePtr();
-                break;
-            case eBasicTypeUnsignedInt128:
-                clang_type = ast->UnsignedInt128Ty.getAsOpaquePtr();
-                break;
-            case eBasicTypeBool:
-                clang_type = ast->BoolTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeHalf:
-                clang_type = ast->HalfTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeFloat:
-                clang_type = ast->FloatTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeDouble:
-                clang_type = ast->DoubleTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeLongDouble:
-                clang_type = ast->LongDoubleTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeFloatComplex:
-                clang_type = ast->FloatComplexTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeDoubleComplex:
-                clang_type = ast->DoubleComplexTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeLongDoubleComplex:
-                clang_type = ast->LongDoubleComplexTy.getAsOpaquePtr();
-                break;
-            case eBasicTypeObjCID:
-                clang_type = ast->getObjCIdType().getAsOpaquePtr();
-                break;
-            case eBasicTypeObjCClass:
-                clang_type = ast->getObjCClassType().getAsOpaquePtr();
-                break;
-            case eBasicTypeObjCSel:
-                clang_type = ast->getObjCSelType().getAsOpaquePtr();
-                break;
-            case eBasicTypeNullPtr:
-                clang_type = ast->NullPtrTy.getAsOpaquePtr();
-                break;
-        }
-        
-        if (clang_type)
-            return CompilerType (GetASTContext(ast), clang_type);
-    }
-    return CompilerType();
-}
-
-
-CompilerType
 ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize (const char *type_name, uint32_t dw_ate, uint32_t bit_size)
 {
     ASTContext *ast = getASTContext();
     
 #define streq(a,b) strcmp(a,b) == 0
     assert (ast != nullptr);
     if (ast)
     {
         switch (dw_ate)
         {
             default:
                 break;
                 
             case DW_ATE_address:
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->VoidPtrTy))
                     return CompilerType (ast, ast->VoidPtrTy);
                 break;
                 
             case DW_ATE_boolean:
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->BoolTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->BoolTy))
                     return CompilerType (ast, ast->BoolTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy))
                     return CompilerType (ast, ast->UnsignedCharTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy))
                     return CompilerType (ast, ast->UnsignedShortTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedIntTy))
                     return CompilerType (ast, ast->UnsignedIntTy);
                 break;
                 
             case DW_ATE_lo_user:
                 // This has been seen to mean DW_AT_complex_integer
                 if (type_name)
                 {
                     if (::strstr(type_name, "complex"))
                     {
                         CompilerType complex_int_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("int", DW_ATE_signed, bit_size/2);
                         return CompilerType(ast, ast->getComplexType(ClangUtil::GetQualType(complex_int_clang_type)));
                     }
                 }
                 break;
                 
             case DW_ATE_complex_float:
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatComplexTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->FloatComplexTy))
                     return CompilerType (ast, ast->FloatComplexTy);
-                else if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleComplexTy))
+                else if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->DoubleComplexTy))
                     return CompilerType (ast, ast->DoubleComplexTy);
-                else if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleComplexTy))
+                else if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->LongDoubleComplexTy))
                     return CompilerType (ast, ast->LongDoubleComplexTy);
                 else 
                 {
                     CompilerType complex_float_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("float", DW_ATE_float, bit_size/2);
                     return CompilerType(ast, ast->getComplexType(ClangUtil::GetQualType(complex_float_clang_type)));
                 }
                 break;
                 
             case DW_ATE_float:
-                if (streq(type_name, "float") && QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
+                if (streq(type_name, "float") && ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->FloatTy))
                     return CompilerType (ast, ast->FloatTy);
-                if (streq(type_name, "double") && QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
+                if (streq(type_name, "double") && ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->DoubleTy))
                     return CompilerType (ast, ast->DoubleTy);
-                if (streq(type_name, "long double") && QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
+                if (streq(type_name, "long double") &&
+                    ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->LongDoubleTy))
                     return CompilerType (ast, ast->LongDoubleTy);
                 // Fall back to not requiring a name match
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->FloatTy))
                     return CompilerType (ast, ast->FloatTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->DoubleTy))
                     return CompilerType (ast, ast->DoubleTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->LongDoubleTy))
                     return CompilerType (ast, ast->LongDoubleTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->HalfTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->HalfTy))
                     return CompilerType (ast, ast->HalfTy);
                 break;
                 
             case DW_ATE_signed:
                 if (type_name)
                 {
-                    if (streq(type_name, "wchar_t") &&
-                        QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy) &&
-                        (getTargetInfo() && TargetInfo::isTypeSigned (getTargetInfo()->getWCharType())))
+                    if (streq(type_name, "wchar_t") && ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->WCharTy) &&
+                        (getTargetInfo() && TargetInfo::isTypeSigned(getTargetInfo()->getWCharType())))
                         return CompilerType (ast, ast->WCharTy);
-                    if (streq(type_name, "void") &&
-                        QualTypeMatchesBitSize (bit_size, ast, ast->VoidTy))
+                    if (streq(type_name, "void") && ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->VoidTy))
                         return CompilerType (ast, ast->VoidTy);
                     if (strstr(type_name, "long long") &&
-                        QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
+                        ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->LongLongTy))
                         return CompilerType (ast, ast->LongLongTy);
-                    if (strstr(type_name, "long") &&
-                        QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
+                    if (strstr(type_name, "long") && ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->LongTy))
                         return CompilerType (ast, ast->LongTy);
-                    if (strstr(type_name, "short") &&
-                        QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
+                    if (strstr(type_name, "short") && ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->ShortTy))
                         return CompilerType (ast, ast->ShortTy);
                     if (strstr(type_name, "char"))
                     {
-                        if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
+                        if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->CharTy))
                             return CompilerType (ast, ast->CharTy);
-                        if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
+                        if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->SignedCharTy))
                             return CompilerType (ast, ast->SignedCharTy);
                     }
                     if (strstr(type_name, "int"))
                     {
-                        if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
+                        if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->IntTy))
                             return CompilerType (ast, ast->IntTy);
-                        if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
+                        if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->Int128Ty))
                             return CompilerType (ast, ast->Int128Ty);
                     }
                 }
                 // We weren't able to match up a type name, just search by size
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->CharTy))
                     return CompilerType (ast, ast->CharTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->ShortTy))
                     return CompilerType (ast, ast->ShortTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->IntTy))
                     return CompilerType (ast, ast->IntTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->LongTy))
                     return CompilerType (ast, ast->LongTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->LongLongTy))
                     return CompilerType (ast, ast->LongLongTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->Int128Ty))
                     return CompilerType (ast, ast->Int128Ty);
                 break;
 
             case DW_ATE_signed_char:
                 if (ast->getLangOpts().CharIsSigned && type_name && streq(type_name, "char"))
                 {
-                    if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
+                    if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->CharTy))
                         return CompilerType (ast, ast->CharTy);
                 }
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->SignedCharTy))
                     return CompilerType (ast, ast->SignedCharTy);
                 break;
                 
             case DW_ATE_unsigned:
                 if (type_name)
                 {
                     if (streq(type_name, "wchar_t"))
                     {
-                        if (QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy))
+                        if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->WCharTy))
                         {
                             if (!(getTargetInfo() && TargetInfo::isTypeSigned (getTargetInfo()->getWCharType())))
                                 return CompilerType (ast, ast->WCharTy);
                         }
                     }
                     if (strstr(type_name, "long long"))
                     {
-                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
+                        if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongLongTy))
                             return CompilerType (ast, ast->UnsignedLongLongTy);
                     }
                     else if (strstr(type_name, "long"))
                     {
-                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
+                        if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongTy))
                             return CompilerType (ast, ast->UnsignedLongTy);
                     }
                     else if (strstr(type_name, "short"))
                     {
-                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
+                        if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy))
                             return CompilerType (ast, ast->UnsignedShortTy);
                     }
                     else if (strstr(type_name, "char"))
                     {
-                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
+                        if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy))
                             return CompilerType (ast, ast->UnsignedCharTy);
                     }
                     else if (strstr(type_name, "int"))
                     {
-                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
+                        if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedIntTy))
                             return CompilerType (ast, ast->UnsignedIntTy);
-                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
+                        if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedInt128Ty))
                             return CompilerType (ast, ast->UnsignedInt128Ty);
                     }
                 }
                 // We weren't able to match up a type name, just search by size
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy))
                     return CompilerType (ast, ast->UnsignedCharTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy))
                     return CompilerType (ast, ast->UnsignedShortTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedIntTy))
                     return CompilerType (ast, ast->UnsignedIntTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongTy))
                     return CompilerType (ast, ast->UnsignedLongTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongLongTy))
                     return CompilerType (ast, ast->UnsignedLongLongTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedInt128Ty))
                     return CompilerType (ast, ast->UnsignedInt128Ty);
                 break;
 
             case DW_ATE_unsigned_char:
                 if (!ast->getLangOpts().CharIsSigned && type_name && streq(type_name, "char"))
                 {
-                    if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
+                    if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->CharTy))
                         return CompilerType (ast, ast->CharTy);
                 }
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy))
                     return CompilerType (ast, ast->UnsignedCharTy);
-                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
+                if (ClangUtil::QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy))
                     return CompilerType (ast, ast->UnsignedShortTy);
                 break;
                 
             case DW_ATE_imaginary_float:
                 break;
                 
             case DW_ATE_UTF:
                 if (type_name)

 ClangASTContext::GetPointerSizedIntType (clang::ASTContext *ast, bool is_signed)
 {
     if (ast)
         return GetIntTypeFromBitSize(ast, ast->getTypeSize(ast->VoidPtrTy), is_signed);
     return CompilerType();
 }
 
 void
-ClangASTContext::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)
-{
-    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, 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 have to check any names of the decl contexts...
-            //------------------------------------------------------------------
-            clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext();
-            clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext();
-            if (lhs_decl_ctx && rhs_decl_ctx)
-            {
-                while (1)
-                {
-                    if (lhs_decl_ctx && rhs_decl_ctx)
-                    {
-                        const clang::Decl::Kind lhs_decl_ctx_kind = lhs_decl_ctx->getDeclKind();
-                        const clang::Decl::Kind rhs_decl_ctx_kind = rhs_decl_ctx->getDeclKind();
-                        if (lhs_decl_ctx_kind == rhs_decl_ctx_kind)
-                        {
-                            lhs_decl_ctx = lhs_decl_ctx->getParent();
-                            rhs_decl_ctx = rhs_decl_ctx->getParent();
-
-                            if (lhs_decl_ctx == nullptr && rhs_decl_ctx == nullptr)
-                                break;
-                        }
-                        else
-                            return false;
-                    }
-                    else
-                        return false;
-                }
-
-                //--------------------------------------------------------------
-                // Now make sure the name of the decls match
-                //--------------------------------------------------------------
-                clang::NamedDecl *lhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(lhs_decl);
-                clang::NamedDecl *rhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(rhs_decl);
-                if (lhs_named_decl && rhs_named_decl)
-                {
-                    clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName();
-                    clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName();
-                    if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind())
-                    {
-                        if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
-                            return false;
-                    }
-                    else
-                        return false;
-                }
-                else
-                    return false;
-
-                //--------------------------------------------------------------
-                // We know that the decl context kinds all match, so now we need
-                // to make sure the names match as well
-                //--------------------------------------------------------------
-                lhs_decl_ctx = lhs_decl->getDeclContext();
-                rhs_decl_ctx = rhs_decl->getDeclContext();
-                while (1)
-                {
-                    switch (lhs_decl_ctx->getDeclKind())
-                    {
-                    case clang::Decl::TranslationUnit:
-                        // We don't care about the translation unit names
-                        return true;
-                    default:
-                        {
-                            clang::NamedDecl *lhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(lhs_decl_ctx);
-                            clang::NamedDecl *rhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(rhs_decl_ctx);
-                            if (lhs_named_decl && rhs_named_decl)
-                            {
-                                clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName();
-                                clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName();
-                                if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind())
-                                {
-                                    if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
-                                        return false;
-                                }
-                                else
-                                    return false;
-                            }
-                            else
-                                return false;
-                        }
-                        break;
-
-                    }
-                    lhs_decl_ctx = lhs_decl_ctx->getParent();
-                    rhs_decl_ctx = rhs_decl_ctx->getParent();
-                }
-            }
-        }
-    }
-    return false;
-}
-bool
-ClangASTContext::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))
-    {
-        if (tag_decl->isCompleteDefinition())
-            return true;
-        
-        if (!tag_decl->hasExternalLexicalStorage())
-            return false;
-        
-        ast_source->CompleteType(tag_decl);
-        
-        return !tag_decl->getTypeForDecl()->isIncompleteType();
-    }
-    else if (clang::ObjCInterfaceDecl *objc_interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
-    {
-        if (objc_interface_decl->getDefinition())
-            return true;
-        
-        if (!objc_interface_decl->hasExternalLexicalStorage())
-            return false;
-        
-        ast_source->CompleteType(objc_interface_decl);
-        
-        return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
-    }
-    else
-    {
-        return false;
-    }
-}
-
-void
 ClangASTContext::SetMetadataAsUserID (const void *object,
                                       user_id_t user_id)
 {
     ClangASTMetadata meta_data;
     meta_data.SetUserID (user_id);
     SetMetadata (object, meta_data);
 }
 

 
 //----------------------------------------------------------------------
 // Create related types using the current type's AST
 //----------------------------------------------------------------------
 
 CompilerType
 ClangASTContext::GetBasicTypeFromAST (lldb::BasicType basic_type)
 {
-    return ClangASTContext::GetBasicType(getASTContext(), basic_type);
+    return ClangUtil::GetBasicType(getASTContext(), basic_type);
 }
 //----------------------------------------------------------------------
 // Exploring the type
 //----------------------------------------------------------------------
 
 uint64_t
 ClangASTContext::GetBitSize (lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope)
 {
switch (type_class)
             break;
     }
     return num_children;
 }
 
 CompilerType
 ClangASTContext::GetBuiltinTypeByName (const ConstString &name)
 {
-    return GetBasicType (GetBasicTypeEnumeration (name));
+    return GetBasicType(ClangUtil::GetBasicTypeEnumeration(name));
 }
 
 lldb::BasicType
 ClangASTContext::GetBasicTypeEnumeration (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         clang::QualType qual_type(GetQualType(type));

source/Symbol/ClangASTImporter.cpp

 ClangASTImporter::CompleteTagDecl (clang::TagDecl *decl)
 {
     ClangASTMetrics::RegisterDeclCompletion();
     
     DeclOrigin decl_origin = GetDeclOrigin(decl);
     
     if (!decl_origin.Valid())
         return false;
-    
-    if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
+    if (!ClangUtil::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
         return false;
     
     MinionSP minion_sp (GetMinion(&decl->getASTContext(), decl_origin.ctx));
     
     if (minion_sp)
         minion_sp->ImportDefinitionTo(decl, decl_origin.decl);
         
     return true;
 }
 
 bool
 ClangASTImporter::CompleteTagDeclWithOrigin(clang::TagDecl *decl, clang::TagDecl *origin_decl)
 {
     ClangASTMetrics::RegisterDeclCompletion();
 
     clang::ASTContext *origin_ast_ctx = &origin_decl->getASTContext();
-        
-    if (!ClangASTContext::GetCompleteDecl(origin_ast_ctx, origin_decl))
+    if (!ClangUtil::GetCompleteDecl(origin_ast_ctx, origin_decl))
         return false;
     
     MinionSP minion_sp (GetMinion(&decl->getASTContext(), origin_ast_ctx));
     
     if (minion_sp)
         minion_sp->ImportDefinitionTo(decl, origin_decl);
         
     ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());

 ClangASTImporter::CompleteObjCInterfaceDecl (clang::ObjCInterfaceDecl *interface_decl)
 {
     ClangASTMetrics::RegisterDeclCompletion();
     
     DeclOrigin decl_origin = GetDeclOrigin(interface_decl);
     
     if (!decl_origin.Valid())
         return false;
-    
-    if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
+    if (!ClangUtil::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
         return false;
     
     MinionSP minion_sp (GetMinion(&interface_decl->getASTContext(), decl_origin.ctx));
     
     if (minion_sp)
         minion_sp->ImportDefinitionTo(interface_decl, decl_origin.decl);
 
     if (ObjCInterfaceDecl *super_class = interface_decl->getSuperClass())
while (!m_decls_to_deport->empty())
         
         DeclOrigin &origin = to_context_md->m_origins[decl];
         UNUSED_IF_ASSERT_DISABLED(origin);
         
         assert (origin.ctx == m_source_ctx);    // otherwise we should never have added this
                                                 // because it doesn't need to be deported
         
         Decl *original_decl = to_context_md->m_origins[decl].decl;
-        
-        ClangASTContext::GetCompleteDecl (m_source_ctx, original_decl);
-        
+        ClangUtil::GetCompleteDecl(m_source_ctx, original_decl);
         if (TagDecl *tag_decl = dyn_cast<TagDecl>(decl))
         {
             if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original_decl))
             {
                 if (original_tag_decl->isCompleteDefinition())
                 {
                     ImportDefinitionTo(tag_decl, original_tag_decl);
                     tag_decl->setCompleteDefinition(true);

source/Symbol/ClangUtil.cpp

 //===-- ClangUtil.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 // A collection of helper methods and data structures for manipulating clang
 // types and decls.
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/ClangUtil.h"
+
+#include "clang/AST/DeclObjC.h"
+
+#include "lldb/Core/ConstString.h"
+#include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Symbol/ClangASTContext.h"
 
+#include "llvm/Support/Dwarf.h"
+
+#include <mutex>
+
 using namespace clang;
+using namespace lldb;
 using namespace lldb_private;
 
 bool
-ClangUtil::IsClangType(const CompilerType &ct)
+ClangUtil::DeclsAreEquivalent(clang::Decl *lhs_decl, clang::Decl *rhs_decl)
 {
-    if (llvm::dyn_cast_or_null<ClangASTContext>(ct.GetTypeSystem()) == nullptr)
+    if (!lhs_decl || !rhs_decl)
         return false;
 
-    if (!ct.GetOpaqueQualType())
+    //----------------------------------------------------------------------
+    // 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)
         return false;
 
+    //------------------------------------------------------------------
+    // Now check that the decl contexts kinds are all equivalent
+    // before we have to check any names of the decl contexts...
+    //------------------------------------------------------------------
+    clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext();
+    clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext();
+    if (!lhs_decl_ctx || !rhs_decl_ctx)
+        return false;
+
+    while (1)
+    {
+        if (!lhs_decl_ctx || !rhs_decl_ctx)
+            return false;
+
+        const clang::Decl::Kind lhs_decl_ctx_kind = lhs_decl_ctx->getDeclKind();
+        const clang::Decl::Kind rhs_decl_ctx_kind = rhs_decl_ctx->getDeclKind();
+        if (lhs_decl_ctx_kind != rhs_decl_ctx_kind)
+            return false;
+
+        lhs_decl_ctx = lhs_decl_ctx->getParent();
+        rhs_decl_ctx = rhs_decl_ctx->getParent();
+
+        if (lhs_decl_ctx == nullptr && rhs_decl_ctx == nullptr)
+            break;
+    }
+
+    //--------------------------------------------------------------
+    // Now make sure the name of the decls match
+    //--------------------------------------------------------------
+    clang::NamedDecl *lhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(lhs_decl);
+    clang::NamedDecl *rhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(rhs_decl);
+    if (!lhs_named_decl || !rhs_named_decl)
+        return false;
+    clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName();
+    clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName();
+    if (lhs_decl_name.getNameKind() != rhs_decl_name.getNameKind())
+        return false;
+    if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
+        return false;
+
+    //--------------------------------------------------------------
+    // We know that the decl context kinds all match, so now we need
+    // to make sure the names match as well
+    //--------------------------------------------------------------
+    lhs_decl_ctx = lhs_decl->getDeclContext();
+    rhs_decl_ctx = rhs_decl->getDeclContext();
+    while (1)
+    {
+        switch (lhs_decl_ctx->getDeclKind())
+        {
+            case clang::Decl::TranslationUnit:
+                // We don't care about the translation unit names
                 return true;
+            default:
+            {
+                clang::NamedDecl *lhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(lhs_decl_ctx);
+                clang::NamedDecl *rhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(rhs_decl_ctx);
+                if (!lhs_named_decl || !rhs_named_decl)
+                    return false;
+                clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName();
+                clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName();
+                if (lhs_decl_name.getNameKind() != rhs_decl_name.getNameKind())
+                    return false;
+                if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
+                    return false;
+            }
+            break;
+        }
+        lhs_decl_ctx = lhs_decl_ctx->getParent();
+        rhs_decl_ctx = rhs_decl_ctx->getParent();
+    }
+    return false;
+}
+
+void
+ClangUtil::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
+ClangUtil::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());
+        }
+    }
+}
+
+CompilerType
+ClangUtil::GetBasicType(clang::ASTContext *ast, BasicType type)
+{
+    lldb::opaque_compiler_type_t clang_type = GetOpaqueCompilerType(ast, type);
+    if (!clang_type)
+        return CompilerType();
+
+    return CompilerType(ast, clang::QualType::getFromOpaquePtr(clang_type));
+}
+
+CompilerType
+ClangUtil::GetBasicType(clang::ASTContext *ast, const ConstString &name)
+{
+    if (!ast)
+        return CompilerType();
+
+    lldb::BasicType basic_type = GetBasicTypeEnumeration(name);
+    return GetBasicType(ast, basic_type);
+}
+
+BasicType
+ClangUtil::GetBasicTypeEnumeration(const ConstString &name)
+{
+    if (!name)
+        return eBasicTypeInvalid;
+    typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
+    static TypeNameToBasicTypeMap g_type_map;
+    static std::once_flag g_once_flag;
+    std::call_once(g_once_flag, []() {
+        // "void"
+        g_type_map.Append(ConstString("void").GetCString(), eBasicTypeVoid);
+
+        // "char"
+        g_type_map.Append(ConstString("char").GetCString(), eBasicTypeChar);
+        g_type_map.Append(ConstString("signed char").GetCString(), eBasicTypeSignedChar);
+        g_type_map.Append(ConstString("unsigned char").GetCString(), eBasicTypeUnsignedChar);
+        g_type_map.Append(ConstString("wchar_t").GetCString(), eBasicTypeWChar);
+        g_type_map.Append(ConstString("signed wchar_t").GetCString(), eBasicTypeSignedWChar);
+        g_type_map.Append(ConstString("unsigned wchar_t").GetCString(), eBasicTypeUnsignedWChar);
+        // "short"
+        g_type_map.Append(ConstString("short").GetCString(), eBasicTypeShort);
+        g_type_map.Append(ConstString("short int").GetCString(), eBasicTypeShort);
+        g_type_map.Append(ConstString("unsigned short").GetCString(), eBasicTypeUnsignedShort);
+        g_type_map.Append(ConstString("unsigned short int").GetCString(), eBasicTypeUnsignedShort);
+
+        // "int"
+        g_type_map.Append(ConstString("int").GetCString(), eBasicTypeInt);
+        g_type_map.Append(ConstString("signed int").GetCString(), eBasicTypeInt);
+        g_type_map.Append(ConstString("unsigned int").GetCString(), eBasicTypeUnsignedInt);
+        g_type_map.Append(ConstString("unsigned").GetCString(), eBasicTypeUnsignedInt);
+
+        // "long"
+        g_type_map.Append(ConstString("long").GetCString(), eBasicTypeLong);
+        g_type_map.Append(ConstString("long int").GetCString(), eBasicTypeLong);
+        g_type_map.Append(ConstString("unsigned long").GetCString(), eBasicTypeUnsignedLong);
+        g_type_map.Append(ConstString("unsigned long int").GetCString(), eBasicTypeUnsignedLong);
+
+        // "long long"
+        g_type_map.Append(ConstString("long long").GetCString(), eBasicTypeLongLong);
+        g_type_map.Append(ConstString("long long int").GetCString(), eBasicTypeLongLong);
+        g_type_map.Append(ConstString("unsigned long long").GetCString(), eBasicTypeUnsignedLongLong);
+        g_type_map.Append(ConstString("unsigned long long int").GetCString(), eBasicTypeUnsignedLongLong);
+
+        // "int128"
+        g_type_map.Append(ConstString("__int128_t").GetCString(), eBasicTypeInt128);
+        g_type_map.Append(ConstString("__uint128_t").GetCString(), eBasicTypeUnsignedInt128);
+
+        // Miscellaneous
+        g_type_map.Append(ConstString("bool").GetCString(), eBasicTypeBool);
+        g_type_map.Append(ConstString("float").GetCString(), eBasicTypeFloat);
+        g_type_map.Append(ConstString("double").GetCString(), eBasicTypeDouble);
+        g_type_map.Append(ConstString("long double").GetCString(), eBasicTypeLongDouble);
+        g_type_map.Append(ConstString("id").GetCString(), eBasicTypeObjCID);
+        g_type_map.Append(ConstString("SEL").GetCString(), eBasicTypeObjCSel);
+        g_type_map.Append(ConstString("nullptr").GetCString(), eBasicTypeNullPtr);
+        g_type_map.Sort();
+    });
+
+    return g_type_map.Find(name.GetCString(), eBasicTypeInvalid);
+}
+
+CompilerType
+ClangUtil::GetBuiltinTypeForEncodingAndBitSize(ASTContext *ast, Encoding encoding, uint32_t bit_size)
+{
+    if (!ast)
+        return CompilerType();
+    switch (encoding)
+    {
+        case eEncodingInvalid:
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->VoidPtrTy))
+                return CompilerType(ast, ast->VoidPtrTy);
+            break;
+
+        case eEncodingUint:
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy))
+                return CompilerType(ast, ast->UnsignedCharTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy))
+                return CompilerType(ast, ast->UnsignedShortTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedIntTy))
+                return CompilerType(ast, ast->UnsignedIntTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongTy))
+                return CompilerType(ast, ast->UnsignedLongTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongLongTy))
+                return CompilerType(ast, ast->UnsignedLongLongTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedInt128Ty))
+                return CompilerType(ast, ast->UnsignedInt128Ty);
+            break;
+
+        case eEncodingSint:
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->CharTy))
+                return CompilerType(ast, ast->CharTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->ShortTy))
+                return CompilerType(ast, ast->ShortTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->IntTy))
+                return CompilerType(ast, ast->IntTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->LongTy))
+                return CompilerType(ast, ast->LongTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->LongLongTy))
+                return CompilerType(ast, ast->LongLongTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->Int128Ty))
+                return CompilerType(ast, ast->Int128Ty);
+            break;
+
+        case eEncodingIEEE754:
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->FloatTy))
+                return CompilerType(ast, ast->FloatTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->DoubleTy))
+                return CompilerType(ast, ast->DoubleTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->LongDoubleTy))
+                return CompilerType(ast, ast->LongDoubleTy);
+            if (QualTypeMatchesBitSize(bit_size, ast, ast->HalfTy))
+                return CompilerType(ast, ast->HalfTy);
+            break;
+
+        case eEncodingVector:
+            // Sanity check that bit_size is a multiple of 8's.
+            if (bit_size && !(bit_size & 0x7u))
+                return CompilerType(ast, ast->getExtVectorType(ast->UnsignedCharTy, bit_size / 8));
+            break;
+    }
+
+    return CompilerType();
 }
 
 QualType
-ClangUtil::GetQualType(const CompilerType &ct)
+ClangUtil::GetCanonicalQualType(const CompilerType &ct)
 {
-    // Make sure we have a clang type before making a clang::QualType
     if (!IsClangType(ct))
         return QualType();
 
-    return QualType::getFromOpaquePtr(ct.GetOpaqueQualType());
+    return GetQualType(ct).getCanonicalType();
+}
+
+bool
+ClangUtil::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))
+    {
+        if (tag_decl->isCompleteDefinition())
+            return true;
+
+        if (!tag_decl->hasExternalLexicalStorage())
+            return false;
+
+        ast_source->CompleteType(tag_decl);
+
+        return !tag_decl->getTypeForDecl()->isIncompleteType();
+    }
+    else if (clang::ObjCInterfaceDecl *objc_interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
+    {
+        if (objc_interface_decl->getDefinition())
+            return true;
+
+        if (!objc_interface_decl->hasExternalLexicalStorage())
+            return false;
+
+        ast_source->CompleteType(objc_interface_decl);
+
+        return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
+    }
+    return false;
+}
+
+opaque_compiler_type_t
+ClangUtil::GetOpaqueCompilerType(clang::ASTContext *ast, BasicType type)
+{
+    if (!ast)
+        return nullptr;
+
+    switch (type)
+    {
+        case eBasicTypeVoid:
+            return ast->VoidTy.getAsOpaquePtr();
+        case eBasicTypeChar:
+            return ast->CharTy.getAsOpaquePtr();
+        case eBasicTypeSignedChar:
+            return ast->SignedCharTy.getAsOpaquePtr();
+        case eBasicTypeUnsignedChar:
+            return ast->UnsignedCharTy.getAsOpaquePtr();
+        case eBasicTypeWChar:
+            return ast->getWCharType().getAsOpaquePtr();
+        case eBasicTypeSignedWChar:
+            return ast->getSignedWCharType().getAsOpaquePtr();
+        case eBasicTypeUnsignedWChar:
+            return ast->getUnsignedWCharType().getAsOpaquePtr();
+        case eBasicTypeChar16:
+            return ast->Char16Ty.getAsOpaquePtr();
+        case eBasicTypeChar32:
+            return ast->Char32Ty.getAsOpaquePtr();
+        case eBasicTypeShort:
+            return ast->ShortTy.getAsOpaquePtr();
+        case eBasicTypeUnsignedShort:
+            return ast->UnsignedShortTy.getAsOpaquePtr();
+        case eBasicTypeInt:
+            return ast->IntTy.getAsOpaquePtr();
+        case eBasicTypeUnsignedInt:
+            return ast->UnsignedIntTy.getAsOpaquePtr();
+        case eBasicTypeLong:
+            return ast->LongTy.getAsOpaquePtr();
+        case eBasicTypeUnsignedLong:
+            return ast->UnsignedLongTy.getAsOpaquePtr();
+        case eBasicTypeLongLong:
+            return ast->LongLongTy.getAsOpaquePtr();
+        case eBasicTypeUnsignedLongLong:
+            return ast->UnsignedLongLongTy.getAsOpaquePtr();
+        case eBasicTypeInt128:
+            return ast->Int128Ty.getAsOpaquePtr();
+        case eBasicTypeUnsignedInt128:
+            return ast->UnsignedInt128Ty.getAsOpaquePtr();
+        case eBasicTypeBool:
+            return ast->BoolTy.getAsOpaquePtr();
+        case eBasicTypeHalf:
+            return ast->HalfTy.getAsOpaquePtr();
+        case eBasicTypeFloat:
+            return ast->FloatTy.getAsOpaquePtr();
+        case eBasicTypeDouble:
+            return ast->DoubleTy.getAsOpaquePtr();
+        case eBasicTypeLongDouble:
+            return ast->LongDoubleTy.getAsOpaquePtr();
+        case eBasicTypeFloatComplex:
+            return ast->FloatComplexTy.getAsOpaquePtr();
+        case eBasicTypeDoubleComplex:
+            return ast->DoubleComplexTy.getAsOpaquePtr();
+        case eBasicTypeLongDoubleComplex:
+            return ast->LongDoubleComplexTy.getAsOpaquePtr();
+        case eBasicTypeObjCID:
+            return ast->getObjCIdType().getAsOpaquePtr();
+        case eBasicTypeObjCClass:
+            return ast->getObjCClassType().getAsOpaquePtr();
+        case eBasicTypeObjCSel:
+            return ast->getObjCSelType().getAsOpaquePtr();
+        case eBasicTypeNullPtr:
+            return ast->NullPtrTy.getAsOpaquePtr();
+        default:
+            return nullptr;
+    }
 }
 
 QualType
-ClangUtil::GetCanonicalQualType(const CompilerType &ct)
+ClangUtil::GetQualType(const CompilerType &ct)
 {
+    // Make sure we have a clang type before making a clang::QualType
     if (!IsClangType(ct))
         return QualType();
 
-    return GetQualType(ct).getCanonicalType();
+    return QualType::getFromOpaquePtr(ct.GetOpaqueQualType());
+}
+
+bool
+ClangUtil::IsClangType(const CompilerType &ct)
+{
+    if (llvm::dyn_cast_or_null<ClangASTContext>(ct.GetTypeSystem()) == nullptr)
+        return false;
+
+    if (!ct.GetOpaqueQualType())
+        return false;
+
+    return true;
+}
+
+bool
+ClangUtil::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
 ClangUtil::RemoveFastQualifiers(const CompilerType &ct)
 {
     if (!IsClangType(ct))
         return ct;
 
     QualType qual_type(GetQualType(ct));
-    qual_type.getQualifiers().removeFastQualifiers();
+    qual_type.removeLocalFastQualifiers();
     return CompilerType(ct.GetTypeSystem(), qual_type.getAsOpaquePtr());
 }

unittests/CMakeLists.txt

 endfunction()
 
 add_subdirectory(Core)
 add_subdirectory(Editline)
 add_subdirectory(Expression)
 add_subdirectory(Host)
 add_subdirectory(Interpreter)
 add_subdirectory(ScriptInterpreter)
+add_subdirectory(Symbol)
 add_subdirectory(SymbolFile)
 add_subdirectory(Utility)

unittests/Symbol/CMakeLists.txt

+add_lldb_unittest(SymbolTests
+  TestClangUtil.cpp
+  )

unittests/Symbol/TestClangUtil.cpp

+//===-- TestClangUtil.cpp ---------------------------------------*- C++ -*-===//
+
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "lldb/Host/HostInfo.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ClangUtil.h"
+#include "lldb/Symbol/GoASTContext.h"
+
+using namespace clang;
+using namespace lldb;
+using namespace lldb_private;
+
+class TestClangUtil : public testing::Test
+{
+public:
+    static void
+    SetUpTestCase()
+    {
+        HostInfo::Initialize();
+    }
+
+    static void
+    TearDownTestCase()
+    {
+        HostInfo::Terminate();
+    }
+
+    virtual void
+    SetUp() override
+    {
+        std::string triple = HostInfo::GetTargetTriple();
+        m_ast.reset(new ClangASTContext(triple.c_str()));
+    }
+
+    virtual void
+    TearDown() override
+    {
+        m_ast.reset();
+    }
+
+protected:
+    std::unique_ptr<ClangASTContext> m_ast;
+
+    QualType
+    GetQualType(BasicType type) const
+    {
+        clang::ASTContext *context = m_ast->getASTContext();
+
+        return ClangUtil::GetQualType(ClangUtil::GetBasicType(context, type));
+    }
+
+    QualType
+    GetQualType(const char *name) const
+    {
+        clang::ASTContext *context = m_ast->getASTContext();
+
+        return ClangUtil::GetQualType(ClangUtil::GetBasicType(context, ConstString(name)));
+    }
+};
+
+TEST_F(TestClangUtil, TestGetBasicTypeFromEnum)
+{
+    clang::ASTContext *context = m_ast->getASTContext();
+
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeBool), context->BoolTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeChar), context->CharTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeChar16), context->Char16Ty));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeChar32), context->Char32Ty));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeDouble), context->DoubleTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeDoubleComplex), context->DoubleComplexTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeFloat), context->FloatTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeFloatComplex), context->FloatComplexTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeHalf), context->HalfTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeInt), context->IntTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeInt128), context->Int128Ty));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeLong), context->LongTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeLongDouble), context->LongDoubleTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeLongDoubleComplex), context->LongDoubleComplexTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeLongLong), context->LongLongTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeNullPtr), context->NullPtrTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeObjCClass), context->getObjCClassType()));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeObjCID), context->getObjCIdType()));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeObjCSel), context->getObjCSelType()));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeShort), context->ShortTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeSignedChar), context->SignedCharTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeUnsignedChar), context->UnsignedCharTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeUnsignedInt), context->UnsignedIntTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeUnsignedInt128), context->UnsignedInt128Ty));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeUnsignedLong), context->UnsignedLongTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeUnsignedLongLong), context->UnsignedLongLongTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeUnsignedShort), context->UnsignedShortTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeVoid), context->VoidTy));
+    EXPECT_TRUE(context->hasSameType(GetQualType(eBasicTypeWChar), context->WCharTy));
+}
+
+TEST_F(TestClangUtil, TestGetBasicTypeFromName)
+{
+    EXPECT_EQ(GetQualType(eBasicTypeChar), GetQualType("char"));
+    EXPECT_EQ(GetQualType(eBasicTypeSignedChar), GetQualType("signed char"));
+    EXPECT_EQ(GetQualType(eBasicTypeUnsignedChar), GetQualType("unsigned char"));
+    EXPECT_EQ(GetQualType(eBasicTypeWChar), GetQualType("wchar_t"));
+    EXPECT_EQ(GetQualType(eBasicTypeSignedWChar), GetQualType("signed wchar_t"));
+    EXPECT_EQ(GetQualType(eBasicTypeUnsignedWChar), GetQualType("unsigned wchar_t"));
+    EXPECT_EQ(GetQualType(eBasicTypeShort), GetQualType("short"));
+    EXPECT_EQ(GetQualType(eBasicTypeShort), GetQualType("short int"));
+    EXPECT_EQ(GetQualType(eBasicTypeUnsignedShort), GetQualType("unsigned short"));
+    EXPECT_EQ(GetQualType(eBasicTypeUnsignedShort), GetQualType("unsigned short int"));
+    EXPECT_EQ(GetQualType(eBasicTypeInt), GetQualType("int"));
+    EXPECT_EQ(GetQualType(eBasicTypeInt), GetQualType("signed int"));
+    EXPECT_EQ(GetQualType(eBasicTypeUnsignedInt), GetQualType("unsigned int"));
+    EXPECT_EQ(GetQualType(eBasicTypeUnsignedInt), GetQualType("unsigned"));
+    EXPECT_EQ(GetQualType(eBasicTypeLong), GetQualType("long"));
+    EXPECT_EQ(GetQualType(eBasicTypeLong), GetQualType("long int"));
+    EXPECT_EQ(GetQualType(eBasicTypeUnsignedLong), GetQualType("unsigned long"));
+    EXPECT_EQ(GetQualType(eBasicTypeUnsignedLong), GetQualType("unsigned long int"));
+    EXPECT_EQ(GetQualType(eBasicTypeLongLong), GetQualType("long long"));
+    EXPECT_EQ(GetQualType(eBasicTypeLongLong), GetQualType("long long int"));
+    EXPECT_EQ(GetQualType(eBasicTypeUnsignedLongLong), GetQualType("unsigned long long"));
+    EXPECT_EQ(GetQualType(eBasicTypeUnsignedLongLong), GetQualType("unsigned long long int"));
+    EXPECT_EQ(GetQualType(eBasicTypeInt128), GetQualType("__int128_t"));
+    EXPECT_EQ(GetQualType(eBasicTypeUnsignedInt128), GetQualType("__uint128_t"));
+    EXPECT_EQ(GetQualType(eBasicTypeVoid), GetQualType("void"));
+    EXPECT_EQ(GetQualType(eBasicTypeBool), GetQualType("bool"));
+    EXPECT_EQ(GetQualType(eBasicTypeFloat), GetQualType("float"));
+    EXPECT_EQ(GetQualType(eBasicTypeDouble), GetQualType("double"));
+    EXPECT_EQ(GetQualType(eBasicTypeLongDouble), GetQualType("long double"));
+    EXPECT_EQ(GetQualType(eBasicTypeObjCID), GetQualType("id"));
+    EXPECT_EQ(GetQualType(eBasicTypeObjCSel), GetQualType("SEL"));
+    EXPECT_EQ(GetQualType(eBasicTypeNullPtr), GetQualType("nullptr"));
+}
+
+void
+VerifyEncodingAndBitSize(clang::ASTContext *context, lldb::Encoding encoding, int bit_size)
+{
+    CompilerType type = ClangUtil::GetBuiltinTypeForEncodingAndBitSize(context, encoding, bit_size);
+    EXPECT_TRUE(type.IsValid());
+
+    QualType qtype = ClangUtil::GetQualType(type);
+    EXPECT_FALSE(qtype.isNull());
+    if (qtype.isNull())
+        return;
+
+    uint64_t actual_size = context->getTypeSize(qtype);
+    EXPECT_EQ(bit_size, actual_size);
+
+    const clang::Type *type_ptr = qtype.getTypePtr();
+    EXPECT_NE(nullptr, type_ptr);
+    if (!type_ptr)
+        return;
+
+    EXPECT_TRUE(type_ptr->isBuiltinType());
+    if (encoding == eEncodingSint)
+        EXPECT_TRUE(type_ptr->isSignedIntegerType());
+    else if (encoding == eEncodingUint)
+        EXPECT_TRUE(type_ptr->isUnsignedIntegerType());
+    else if (encoding == eEncodingIEEE754)
+        EXPECT_TRUE(type_ptr->isFloatingType());
+}
+
+TEST_F(TestClangUtil, TestBuiltinTypeForEncodingAndBitSize)
+{
+    clang::ASTContext *context = m_ast->getASTContext();
+
+    // 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(context, eEncodingSint, 8);
+    VerifyEncodingAndBitSize(context, eEncodingSint, 16);
+    VerifyEncodingAndBitSize(context, eEncodingSint, 32);
+    VerifyEncodingAndBitSize(context, eEncodingSint, 64);
+    VerifyEncodingAndBitSize(context, eEncodingSint, 128);
+
+    VerifyEncodingAndBitSize(context, eEncodingUint, 8);
+    VerifyEncodingAndBitSize(context, eEncodingUint, 16);
+    VerifyEncodingAndBitSize(context, eEncodingUint, 32);
+    VerifyEncodingAndBitSize(context, eEncodingUint, 64);
+    VerifyEncodingAndBitSize(context, eEncodingUint, 128);
+
+    VerifyEncodingAndBitSize(context, eEncodingIEEE754, 32);
+    VerifyEncodingAndBitSize(context, eEncodingIEEE754, 64);
+}
+
+TEST_F(TestClangUtil, TestIsClangType)
+{
+    clang::ASTContext *context = m_ast->getASTContext();
+    lldb::opaque_compiler_type_t bool_ctype = ClangUtil::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()));
+
+    // Go type should fail
+    GoASTContext go_ast;
+    CompilerType go_type(&go_ast, bool_ctype);
+    EXPECT_FALSE(ClangUtil::IsClangType(go_type));
+}
+
+TEST_F(TestClangUtil, 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(0, qt.getLocalFastQualifiers());
+    record_type = record_type.AddConstModifier();
+    record_type = record_type.AddVolatileModifier();
+    record_type = record_type.AddRestrictModifier();
+    qt = ClangUtil::GetQualType(record_type);
+    EXPECT_NE(0, qt.getLocalFastQualifiers());
+    record_type = ClangUtil::RemoveFastQualifiers(record_type);
+    qt = ClangUtil::GetQualType(record_type);
+    EXPECT_EQ(0, qt.getLocalFastQualifiers());
+}