*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 1771 insertions, 1874 deletions

diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp
index a0ea8ae730f..3fa78f01f51 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp
@@ -14,11 +14,6 @@
 #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"
@@ -30,9 +25,9 @@
 #include "lldb/Expression/Materializer.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.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"
@@ -50,6 +45,11 @@
 #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"
 
@@ -57,1586 +57,1501 @@ using namespace lldb;
 using namespace lldb_private;
 using namespace clang;
 
-namespace
-{
-    const char *g_lldb_local_vars_namespace_cstr = "$__lldb_local_vars";
+namespace {
+const char *g_lldb_local_vars_namespace_cstr = "$__lldb_local_vars";
 } // anonymous namespace
 
-ClangExpressionDeclMap::ClangExpressionDeclMap (bool keep_result_in_memory,
-                                                Materializer::PersistentVariableDelegate *result_delegate,
-                                                ExecutionContext &exe_ctx) :
-    ClangASTSource (exe_ctx.GetTargetSP()),
-    m_found_entities (),
-    m_struct_members (),
-    m_keep_result_in_memory (keep_result_in_memory),
-    m_result_delegate (result_delegate),
-    m_parser_vars (),
-    m_struct_vars ()
-{
-    EnableStructVars();
+ClangExpressionDeclMap::ClangExpressionDeclMap(
+    bool keep_result_in_memory,
+    Materializer::PersistentVariableDelegate *result_delegate,
+    ExecutionContext &exe_ctx)
+    : ClangASTSource(exe_ctx.GetTargetSP()), m_found_entities(),
+      m_struct_members(), m_keep_result_in_memory(keep_result_in_memory),
+      m_result_delegate(result_delegate), m_parser_vars(), m_struct_vars() {
+  EnableStructVars();
 }
 
-ClangExpressionDeclMap::~ClangExpressionDeclMap()
-{
-    // Note: The model is now that the parser's AST context and all associated
-    //   data does not vanish until the expression has been executed.  This means
-    //   that valuable lookup data (like namespaces) doesn't vanish, but
+ClangExpressionDeclMap::~ClangExpressionDeclMap() {
+  // Note: The model is now that the parser's AST context and all associated
+  //   data does not vanish until the expression has been executed.  This means
+  //   that valuable lookup data (like namespaces) doesn't vanish, but
 
-    DidParse();
-    DisableStructVars();
+  DidParse();
+  DisableStructVars();
 }
 
-bool
-ClangExpressionDeclMap::WillParse(ExecutionContext &exe_ctx,
-                                  Materializer *materializer)
-{
-    ClangASTMetrics::ClearLocalCounters();
-
-    EnableParserVars();
-    m_parser_vars->m_exe_ctx = exe_ctx;
-
-    Target *target = exe_ctx.GetTargetPtr();
-    if (exe_ctx.GetFramePtr())
-        m_parser_vars->m_sym_ctx = exe_ctx.GetFramePtr()->GetSymbolContext(lldb::eSymbolContextEverything);
-    else if (exe_ctx.GetThreadPtr() && exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0))
-        m_parser_vars->m_sym_ctx = exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0)->GetSymbolContext(lldb::eSymbolContextEverything);
-    else if (exe_ctx.GetProcessPtr())
-    {
-        m_parser_vars->m_sym_ctx.Clear(true);
-        m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
-    }
-    else if (target)
-    {
-        m_parser_vars->m_sym_ctx.Clear(true);
-        m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
-    }
-
-    if (target)
-    {
-        m_parser_vars->m_persistent_vars = llvm::cast<ClangPersistentVariables>(target->GetPersistentExpressionStateForLanguage(eLanguageTypeC));
-
-        if (!target->GetScratchClangASTContext())
-            return false;
-    }
-
-    m_parser_vars->m_target_info = GetTargetInfo();
-    m_parser_vars->m_materializer = materializer;
-
-    return true;
+bool ClangExpressionDeclMap::WillParse(ExecutionContext &exe_ctx,
+                                       Materializer *materializer) {
+  ClangASTMetrics::ClearLocalCounters();
+
+  EnableParserVars();
+  m_parser_vars->m_exe_ctx = exe_ctx;
+
+  Target *target = exe_ctx.GetTargetPtr();
+  if (exe_ctx.GetFramePtr())
+    m_parser_vars->m_sym_ctx =
+        exe_ctx.GetFramePtr()->GetSymbolContext(lldb::eSymbolContextEverything);
+  else if (exe_ctx.GetThreadPtr() &&
+           exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0))
+    m_parser_vars->m_sym_ctx =
+        exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0)->GetSymbolContext(
+            lldb::eSymbolContextEverything);
+  else if (exe_ctx.GetProcessPtr()) {
+    m_parser_vars->m_sym_ctx.Clear(true);
+    m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
+  } else if (target) {
+    m_parser_vars->m_sym_ctx.Clear(true);
+    m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
+  }
+
+  if (target) {
+    m_parser_vars->m_persistent_vars = llvm::cast<ClangPersistentVariables>(
+        target->GetPersistentExpressionStateForLanguage(eLanguageTypeC));
+
+    if (!target->GetScratchClangASTContext())
+      return false;
+  }
+
+  m_parser_vars->m_target_info = GetTargetInfo();
+  m_parser_vars->m_materializer = materializer;
+
+  return true;
 }
 
-void
-ClangExpressionDeclMap::InstallCodeGenerator (clang::ASTConsumer *code_gen)
-{
-    assert(m_parser_vars);
-    m_parser_vars->m_code_gen = code_gen;
+void ClangExpressionDeclMap::InstallCodeGenerator(
+    clang::ASTConsumer *code_gen) {
+  assert(m_parser_vars);
+  m_parser_vars->m_code_gen = code_gen;
 }
 
-void
-ClangExpressionDeclMap::DidParse()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+void ClangExpressionDeclMap::DidParse() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    if (log)
-        ClangASTMetrics::DumpCounters(log);
-
-    if (m_parser_vars.get())
-    {
-        for (size_t entity_index = 0, num_entities = m_found_entities.GetSize();
-             entity_index < num_entities;
-             ++entity_index)
-        {
-            ExpressionVariableSP var_sp(m_found_entities.GetVariableAtIndex(entity_index));
-            if (var_sp)
-                llvm::cast<ClangExpressionVariable>(var_sp.get())->DisableParserVars(GetParserID());
-        }
+  if (log)
+    ClangASTMetrics::DumpCounters(log);
 
-        for (size_t pvar_index = 0, num_pvars = m_parser_vars->m_persistent_vars->GetSize();
-             pvar_index < num_pvars;
-             ++pvar_index)
-        {
-            ExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariableAtIndex(pvar_index));
-            if (ClangExpressionVariable *clang_var = llvm::dyn_cast<ClangExpressionVariable>(pvar_sp.get()))
-                clang_var->DisableParserVars(GetParserID());
-        }
+  if (m_parser_vars.get()) {
+    for (size_t entity_index = 0, num_entities = m_found_entities.GetSize();
+         entity_index < num_entities; ++entity_index) {
+      ExpressionVariableSP var_sp(
+          m_found_entities.GetVariableAtIndex(entity_index));
+      if (var_sp)
+        llvm::cast<ClangExpressionVariable>(var_sp.get())
+            ->DisableParserVars(GetParserID());
+    }
 
-        DisableParserVars();
+    for (size_t pvar_index = 0,
+                num_pvars = m_parser_vars->m_persistent_vars->GetSize();
+         pvar_index < num_pvars; ++pvar_index) {
+      ExpressionVariableSP pvar_sp(
+          m_parser_vars->m_persistent_vars->GetVariableAtIndex(pvar_index));
+      if (ClangExpressionVariable *clang_var =
+              llvm::dyn_cast<ClangExpressionVariable>(pvar_sp.get()))
+        clang_var->DisableParserVars(GetParserID());
     }
+
+    DisableParserVars();
+  }
 }
 
 // Interface for IRForTarget
 
-ClangExpressionDeclMap::TargetInfo
-ClangExpressionDeclMap::GetTargetInfo()
-{
-    assert (m_parser_vars.get());
+ClangExpressionDeclMap::TargetInfo ClangExpressionDeclMap::GetTargetInfo() {
+  assert(m_parser_vars.get());
 
-    TargetInfo ret;
+  TargetInfo ret;
 
-    ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
+  ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
 
-    Process *process = exe_ctx.GetProcessPtr();
-    if (process)
-    {
-        ret.byte_order = process->GetByteOrder();
-        ret.address_byte_size = process->GetAddressByteSize();
-    }
-    else
-    {
-        Target *target = exe_ctx.GetTargetPtr();
-        if (target)
-        {
-            ret.byte_order = target->GetArchitecture().GetByteOrder();
-            ret.address_byte_size = target->GetArchitecture().GetAddressByteSize();
-        }
+  Process *process = exe_ctx.GetProcessPtr();
+  if (process) {
+    ret.byte_order = process->GetByteOrder();
+    ret.address_byte_size = process->GetAddressByteSize();
+  } else {
+    Target *target = exe_ctx.GetTargetPtr();
+    if (target) {
+      ret.byte_order = target->GetArchitecture().GetByteOrder();
+      ret.address_byte_size = target->GetArchitecture().GetAddressByteSize();
     }
+  }
 
-    return ret;
+  return ret;
 }
 
-bool
-ClangExpressionDeclMap::AddPersistentVariable
-(
-    const NamedDecl *decl,
-    const ConstString &name,
-    TypeFromParser parser_type,
-    bool is_result,
-    bool is_lvalue
-)
-{
-    assert (m_parser_vars.get());
-
-    ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(parser_type.GetTypeSystem());
-    if (ast == nullptr)
-        return false;
+bool ClangExpressionDeclMap::AddPersistentVariable(const NamedDecl *decl,
+                                                   const ConstString &name,
+                                                   TypeFromParser parser_type,
+                                                   bool is_result,
+                                                   bool is_lvalue) {
+  assert(m_parser_vars.get());
 
-    if (m_parser_vars->m_materializer && is_result)
-    {
-        Error err;
+  ClangASTContext *ast =
+      llvm::dyn_cast_or_null<ClangASTContext>(parser_type.GetTypeSystem());
+  if (ast == nullptr)
+    return false;
 
-        ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
-        Target *target = exe_ctx.GetTargetPtr();
-        if (target == nullptr)
-            return false;
+  if (m_parser_vars->m_materializer && is_result) {
+    Error err;
 
-        ClangASTContext *context(target->GetScratchClangASTContext());
+    ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
+    Target *target = exe_ctx.GetTargetPtr();
+    if (target == nullptr)
+      return false;
 
-        TypeFromUser user_type(m_ast_importer_sp->DeportType(context->getASTContext(),
-                                                             ast->getASTContext(),
-                                                             parser_type.GetOpaqueQualType()),
-                               context);
-        
-        uint32_t offset = m_parser_vars->m_materializer->AddResultVariable(user_type,
-                                                                           is_lvalue,
-                                                                           m_keep_result_in_memory,
-                                                                           m_result_delegate,
-                                                                           err);
+    ClangASTContext *context(target->GetScratchClangASTContext());
 
-        ClangExpressionVariable *var = new ClangExpressionVariable(exe_ctx.GetBestExecutionContextScope(),
-                                                                   name,
-                                                                   user_type,
-                                                                   m_parser_vars->m_target_info.byte_order,
-                                                                   m_parser_vars->m_target_info.address_byte_size);
+    TypeFromUser user_type(m_ast_importer_sp->DeportType(
+                               context->getASTContext(), ast->getASTContext(),
+                               parser_type.GetOpaqueQualType()),
+                           context);
 
-        m_found_entities.AddNewlyConstructedVariable(var);
-        
-        var->EnableParserVars(GetParserID());
+    uint32_t offset = m_parser_vars->m_materializer->AddResultVariable(
+        user_type, is_lvalue, m_keep_result_in_memory, m_result_delegate, err);
 
-        ClangExpressionVariable::ParserVars *parser_vars = var->GetParserVars(GetParserID());
+    ClangExpressionVariable *var = new ClangExpressionVariable(
+        exe_ctx.GetBestExecutionContextScope(), name, user_type,
+        m_parser_vars->m_target_info.byte_order,
+        m_parser_vars->m_target_info.address_byte_size);
 
-        parser_vars->m_named_decl = decl;
-        parser_vars->m_parser_type = parser_type;
+    m_found_entities.AddNewlyConstructedVariable(var);
 
-        var->EnableJITVars(GetParserID());
+    var->EnableParserVars(GetParserID());
 
-        ClangExpressionVariable::JITVars *jit_vars = var->GetJITVars(GetParserID());
+    ClangExpressionVariable::ParserVars *parser_vars =
+        var->GetParserVars(GetParserID());
 
-        jit_vars->m_offset = offset;
+    parser_vars->m_named_decl = decl;
+    parser_vars->m_parser_type = parser_type;
 
-        return true;
-    }
+    var->EnableJITVars(GetParserID());
 
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-    ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
-    Target *target = exe_ctx.GetTargetPtr();
-    if (target == NULL)
-        return false;
+    ClangExpressionVariable::JITVars *jit_vars = var->GetJITVars(GetParserID());
 
-    ClangASTContext *context(target->GetScratchClangASTContext());
+    jit_vars->m_offset = offset;
 
-    TypeFromUser user_type(m_ast_importer_sp->DeportType(context->getASTContext(),
-                                                         ast->getASTContext(),
-                                                         parser_type.GetOpaqueQualType()),
-                           context);
+    return true;
+  }
 
-    if (!user_type.GetOpaqueQualType())
-    {
-        if (log)
-            log->Printf("Persistent variable's type wasn't copied successfully");
-        return false;
-    }
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+  ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
+  Target *target = exe_ctx.GetTargetPtr();
+  if (target == NULL)
+    return false;
 
-    if (!m_parser_vars->m_target_info.IsValid())
-        return false;
+  ClangASTContext *context(target->GetScratchClangASTContext());
 
-    ClangExpressionVariable *var = llvm::cast<ClangExpressionVariable>(m_parser_vars->m_persistent_vars->CreatePersistentVariable (exe_ctx.GetBestExecutionContextScope (),
-                                                                                                                                   name,
-                                                                                                                                   user_type,
-                                                                                                                                   m_parser_vars->m_target_info.byte_order,
-                                                                                                                                   m_parser_vars->m_target_info.address_byte_size).get());
+  TypeFromUser user_type(m_ast_importer_sp->DeportType(
+                             context->getASTContext(), ast->getASTContext(),
+                             parser_type.GetOpaqueQualType()),
+                         context);
 
-    if (!var)
-        return false;
+  if (!user_type.GetOpaqueQualType()) {
+    if (log)
+      log->Printf("Persistent variable's type wasn't copied successfully");
+    return false;
+  }
 
-    var->m_frozen_sp->SetHasCompleteType();
+  if (!m_parser_vars->m_target_info.IsValid())
+    return false;
 
-    if (is_result)
-        var->m_flags |= ClangExpressionVariable::EVNeedsFreezeDry;
-    else
-        var->m_flags |= ClangExpressionVariable::EVKeepInTarget; // explicitly-declared persistent variables should persist
+  ClangExpressionVariable *var = llvm::cast<ClangExpressionVariable>(
+      m_parser_vars->m_persistent_vars
+          ->CreatePersistentVariable(
+              exe_ctx.GetBestExecutionContextScope(), name, user_type,
+              m_parser_vars->m_target_info.byte_order,
+              m_parser_vars->m_target_info.address_byte_size)
+          .get());
 
-    if (is_lvalue)
-    {
-        var->m_flags |= ClangExpressionVariable::EVIsProgramReference;
-    }
-    else
-    {
-        var->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
-        var->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
-    }
+  if (!var)
+    return false;
 
-    if (m_keep_result_in_memory)
-    {
-        var->m_flags |= ClangExpressionVariable::EVKeepInTarget;
-    }
+  var->m_frozen_sp->SetHasCompleteType();
 
-    if (log)
-        log->Printf("Created persistent variable with flags 0x%hx", var->m_flags);
+  if (is_result)
+    var->m_flags |= ClangExpressionVariable::EVNeedsFreezeDry;
+  else
+    var->m_flags |=
+        ClangExpressionVariable::EVKeepInTarget; // explicitly-declared
+                                                 // persistent variables should
+                                                 // persist
 
-    var->EnableParserVars(GetParserID());
+  if (is_lvalue) {
+    var->m_flags |= ClangExpressionVariable::EVIsProgramReference;
+  } else {
+    var->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
+    var->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
+  }
 
-    ClangExpressionVariable::ParserVars *parser_vars = var->GetParserVars(GetParserID());
+  if (m_keep_result_in_memory) {
+    var->m_flags |= ClangExpressionVariable::EVKeepInTarget;
+  }
 
-    parser_vars->m_named_decl = decl;
-    parser_vars->m_parser_type = parser_type;
+  if (log)
+    log->Printf("Created persistent variable with flags 0x%hx", var->m_flags);
 
-    return true;
-}
+  var->EnableParserVars(GetParserID());
 
-bool
-ClangExpressionDeclMap::AddValueToStruct
-(
-    const NamedDecl *decl,
-    const ConstString &name,
-    llvm::Value *value,
-    size_t size,
-    lldb::offset_t alignment
-)
-{
-    assert (m_struct_vars.get());
-    assert (m_parser_vars.get());
+  ClangExpressionVariable::ParserVars *parser_vars =
+      var->GetParserVars(GetParserID());
 
-    bool is_persistent_variable = false;
+  parser_vars->m_named_decl = decl;
+  parser_vars->m_parser_type = parser_type;
 
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+  return true;
+}
 
-    m_struct_vars->m_struct_laid_out = false;
+bool ClangExpressionDeclMap::AddValueToStruct(const NamedDecl *decl,
+                                              const ConstString &name,
+                                              llvm::Value *value, size_t size,
+                                              lldb::offset_t alignment) {
+  assert(m_struct_vars.get());
+  assert(m_parser_vars.get());
 
-    if (ClangExpressionVariable::FindVariableInList(m_struct_members, decl, GetParserID()))
-        return true;
+  bool is_persistent_variable = false;
 
-    ClangExpressionVariable *var(ClangExpressionVariable::FindVariableInList(m_found_entities, decl, GetParserID()));
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    if (!var)
-    {
-        var = ClangExpressionVariable::FindVariableInList(*m_parser_vars->m_persistent_vars, decl, GetParserID());
-        is_persistent_variable = true;
-    }
+  m_struct_vars->m_struct_laid_out = false;
 
-    if (!var)
-        return false;
+  if (ClangExpressionVariable::FindVariableInList(m_struct_members, decl,
+                                                  GetParserID()))
+    return true;
 
-    if (log)
-        log->Printf("Adding value for (NamedDecl*)%p [%s - %s] to the structure",
-                    static_cast<const void*>(decl), name.GetCString(),
-                    var->GetName().GetCString());
+  ClangExpressionVariable *var(ClangExpressionVariable::FindVariableInList(
+      m_found_entities, decl, GetParserID()));
 
-    // We know entity->m_parser_vars is valid because we used a parser variable
-    // to find it
+  if (!var) {
+    var = ClangExpressionVariable::FindVariableInList(
+        *m_parser_vars->m_persistent_vars, decl, GetParserID());
+    is_persistent_variable = true;
+  }
 
-    ClangExpressionVariable::ParserVars *parser_vars = llvm::cast<ClangExpressionVariable>(var)->GetParserVars(GetParserID());
+  if (!var)
+    return false;
 
-    parser_vars->m_llvm_value = value;
+  if (log)
+    log->Printf("Adding value for (NamedDecl*)%p [%s - %s] to the structure",
+                static_cast<const void *>(decl), name.GetCString(),
+                var->GetName().GetCString());
 
-    if (ClangExpressionVariable::JITVars *jit_vars = llvm::cast<ClangExpressionVariable>(var)->GetJITVars(GetParserID()))
-    {
-        // We already laid this out; do not touch
+  // We know entity->m_parser_vars is valid because we used a parser variable
+  // to find it
 
-        if (log)
-            log->Printf("Already placed at 0x%llx", (unsigned long long)jit_vars->m_offset);
-    }
+  ClangExpressionVariable::ParserVars *parser_vars =
+      llvm::cast<ClangExpressionVariable>(var)->GetParserVars(GetParserID());
 
-    llvm::cast<ClangExpressionVariable>(var)->EnableJITVars(GetParserID());
+  parser_vars->m_llvm_value = value;
 
-    ClangExpressionVariable::JITVars *jit_vars = llvm::cast<ClangExpressionVariable>(var)->GetJITVars(GetParserID());
+  if (ClangExpressionVariable::JITVars *jit_vars =
+          llvm::cast<ClangExpressionVariable>(var)->GetJITVars(GetParserID())) {
+    // We already laid this out; do not touch
 
-    jit_vars->m_alignment = alignment;
-    jit_vars->m_size = size;
+    if (log)
+      log->Printf("Already placed at 0x%llx",
+                  (unsigned long long)jit_vars->m_offset);
+  }
 
-    m_struct_members.AddVariable(var->shared_from_this());
+  llvm::cast<ClangExpressionVariable>(var)->EnableJITVars(GetParserID());
 
-    if (m_parser_vars->m_materializer)
-    {
-        uint32_t offset = 0;
+  ClangExpressionVariable::JITVars *jit_vars =
+      llvm::cast<ClangExpressionVariable>(var)->GetJITVars(GetParserID());
 
-        Error err;
+  jit_vars->m_alignment = alignment;
+  jit_vars->m_size = size;
 
-        if (is_persistent_variable)
-        {
-            ExpressionVariableSP var_sp(var->shared_from_this());
-            offset = m_parser_vars->m_materializer->AddPersistentVariable(var_sp, nullptr, err);
-        }
-        else
-        {
-            if (const lldb_private::Symbol *sym = parser_vars->m_lldb_sym)
-                offset = m_parser_vars->m_materializer->AddSymbol(*sym, err);
-            else if (const RegisterInfo *reg_info = var->GetRegisterInfo())
-                offset = m_parser_vars->m_materializer->AddRegister(*reg_info, err);
-            else if (parser_vars->m_lldb_var)
-                offset = m_parser_vars->m_materializer->AddVariable(parser_vars->m_lldb_var, err);
-        }
+  m_struct_members.AddVariable(var->shared_from_this());
 
-        if (!err.Success())
-            return false;
+  if (m_parser_vars->m_materializer) {
+    uint32_t offset = 0;
 
-        if (log)
-            log->Printf("Placed at 0x%llx", (unsigned long long)offset);
+    Error err;
 
-        jit_vars->m_offset = offset; // TODO DoStructLayout() should not change this.
+    if (is_persistent_variable) {
+      ExpressionVariableSP var_sp(var->shared_from_this());
+      offset = m_parser_vars->m_materializer->AddPersistentVariable(
+          var_sp, nullptr, err);
+    } else {
+      if (const lldb_private::Symbol *sym = parser_vars->m_lldb_sym)
+        offset = m_parser_vars->m_materializer->AddSymbol(*sym, err);
+      else if (const RegisterInfo *reg_info = var->GetRegisterInfo())
+        offset = m_parser_vars->m_materializer->AddRegister(*reg_info, err);
+      else if (parser_vars->m_lldb_var)
+        offset = m_parser_vars->m_materializer->AddVariable(
+            parser_vars->m_lldb_var, err);
     }
 
-    return true;
-}
-
-bool
-ClangExpressionDeclMap::DoStructLayout ()
-{
-    assert (m_struct_vars.get());
+    if (!err.Success())
+      return false;
 
-    if (m_struct_vars->m_struct_laid_out)
-        return true;
+    if (log)
+      log->Printf("Placed at 0x%llx", (unsigned long long)offset);
 
-    if (!m_parser_vars->m_materializer)
-        return false;
+    jit_vars->m_offset =
+        offset; // TODO DoStructLayout() should not change this.
+  }
 
-    m_struct_vars->m_struct_alignment = m_parser_vars->m_materializer->GetStructAlignment();
-    m_struct_vars->m_struct_size = m_parser_vars->m_materializer->GetStructByteSize();
-    m_struct_vars->m_struct_laid_out = true;
-    return true;
+  return true;
 }
 
-bool ClangExpressionDeclMap::GetStructInfo
-(
-    uint32_t &num_elements,
-    size_t &size,
-    lldb::offset_t &alignment
-)
-{
-    assert (m_struct_vars.get());
+bool ClangExpressionDeclMap::DoStructLayout() {
+  assert(m_struct_vars.get());
 
-    if (!m_struct_vars->m_struct_laid_out)
-        return false;
+  if (m_struct_vars->m_struct_laid_out)
+    return true;
 
-    num_elements = m_struct_members.GetSize();
-    size = m_struct_vars->m_struct_size;
-    alignment = m_struct_vars->m_struct_alignment;
+  if (!m_parser_vars->m_materializer)
+    return false;
 
-    return true;
+  m_struct_vars->m_struct_alignment =
+      m_parser_vars->m_materializer->GetStructAlignment();
+  m_struct_vars->m_struct_size =
+      m_parser_vars->m_materializer->GetStructByteSize();
+  m_struct_vars->m_struct_laid_out = true;
+  return true;
 }
 
-bool
-ClangExpressionDeclMap::GetStructElement
-(
-    const NamedDecl *&decl,
-    llvm::Value *&value,
-    lldb::offset_t &offset,
-    ConstString &name,
-    uint32_t index
-)
-{
-    assert (m_struct_vars.get());
-
-    if (!m_struct_vars->m_struct_laid_out)
-        return false;
+bool ClangExpressionDeclMap::GetStructInfo(uint32_t &num_elements, size_t &size,
+                                           lldb::offset_t &alignment) {
+  assert(m_struct_vars.get());
 
-    if (index >= m_struct_members.GetSize())
-        return false;
+  if (!m_struct_vars->m_struct_laid_out)
+    return false;
 
-    ExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(index));
+  num_elements = m_struct_members.GetSize();
+  size = m_struct_vars->m_struct_size;
+  alignment = m_struct_vars->m_struct_alignment;
 
-    if (!member_sp)
-        return false;
-
-    ClangExpressionVariable::ParserVars *parser_vars = llvm::cast<ClangExpressionVariable>(member_sp.get())->GetParserVars(GetParserID());
-    ClangExpressionVariable::JITVars *jit_vars = llvm::cast<ClangExpressionVariable>(member_sp.get())->GetJITVars(GetParserID());
+  return true;
+}
 
-    if (!parser_vars ||
-        !jit_vars ||
-        !member_sp->GetValueObject())
-        return false;
+bool ClangExpressionDeclMap::GetStructElement(const NamedDecl *&decl,
+                                              llvm::Value *&value,
+                                              lldb::offset_t &offset,
+                                              ConstString &name,
+                                              uint32_t index) {
+  assert(m_struct_vars.get());
 
-    decl = parser_vars->m_named_decl;
-    value = parser_vars->m_llvm_value;
-    offset = jit_vars->m_offset;
-    name = member_sp->GetName();
+  if (!m_struct_vars->m_struct_laid_out)
+    return false;
 
-    return true;
-}
+  if (index >= m_struct_members.GetSize())
+    return false;
 
-bool
-ClangExpressionDeclMap::GetFunctionInfo
-(
-    const NamedDecl *decl,
-    uint64_t &ptr
-)
-{
-    ClangExpressionVariable *entity(ClangExpressionVariable::FindVariableInList(m_found_entities, decl, GetParserID()));
+  ExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(index));
 
-    if (!entity)
-        return false;
+  if (!member_sp)
+    return false;
 
-    // We know m_parser_vars is valid since we searched for the variable by
-    // its NamedDecl
+  ClangExpressionVariable::ParserVars *parser_vars =
+      llvm::cast<ClangExpressionVariable>(member_sp.get())
+          ->GetParserVars(GetParserID());
+  ClangExpressionVariable::JITVars *jit_vars =
+      llvm::cast<ClangExpressionVariable>(member_sp.get())
+          ->GetJITVars(GetParserID());
 
-    ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
+  if (!parser_vars || !jit_vars || !member_sp->GetValueObject())
+    return false;
 
-    ptr = parser_vars->m_lldb_value.GetScalar().ULongLong();
+  decl = parser_vars->m_named_decl;
+  value = parser_vars->m_llvm_value;
+  offset = jit_vars->m_offset;
+  name = member_sp->GetName();
 
-    return true;
+  return true;
 }
 
-addr_t
-ClangExpressionDeclMap::GetSymbolAddress (Target &target,
-                                          Process *process,
-                                          const ConstString &name,
-                                          lldb::SymbolType symbol_type,
-                                          lldb_private::Module *module)
-{
-    SymbolContextList sc_list;
-
-    if (module)
-        module->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
-    else
-        target.GetImages().FindSymbolsWithNameAndType(name, symbol_type, sc_list);
-
-    const uint32_t num_matches = sc_list.GetSize();
-    addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
+bool ClangExpressionDeclMap::GetFunctionInfo(const NamedDecl *decl,
+                                             uint64_t &ptr) {
+  ClangExpressionVariable *entity(ClangExpressionVariable::FindVariableInList(
+      m_found_entities, decl, GetParserID()));
 
-    for (uint32_t i=0; i<num_matches && (symbol_load_addr == 0 || symbol_load_addr == LLDB_INVALID_ADDRESS); i++)
-    {
-        SymbolContext sym_ctx;
-        sc_list.GetContextAtIndex(i, sym_ctx);
+  if (!entity)
+    return false;
 
-        const Address sym_address = sym_ctx.symbol->GetAddress();
+  // We know m_parser_vars is valid since we searched for the variable by
+  // its NamedDecl
 
-        if (!sym_address.IsValid())
-            continue;
+  ClangExpressionVariable::ParserVars *parser_vars =
+      entity->GetParserVars(GetParserID());
 
-        switch (sym_ctx.symbol->GetType())
-        {
-            case eSymbolTypeCode:
-            case eSymbolTypeTrampoline:
-                symbol_load_addr = sym_address.GetCallableLoadAddress (&target);
-                break;
-
-            case eSymbolTypeResolver:
-                symbol_load_addr = sym_address.GetCallableLoadAddress (&target, true);
-                break;
+  ptr = parser_vars->m_lldb_value.GetScalar().ULongLong();
 
-            case eSymbolTypeReExported:
-                {
-                    ConstString reexport_name = sym_ctx.symbol->GetReExportedSymbolName();
-                    if (reexport_name)
-                    {
-                        ModuleSP reexport_module_sp;
-                        ModuleSpec reexport_module_spec;
-                        reexport_module_spec.GetPlatformFileSpec() = sym_ctx.symbol->GetReExportedSymbolSharedLibrary();
-                        if (reexport_module_spec.GetPlatformFileSpec())
-                        {
-                            reexport_module_sp = target.GetImages().FindFirstModule(reexport_module_spec);
-                            if (!reexport_module_sp)
-                            {
-                                reexport_module_spec.GetPlatformFileSpec().GetDirectory().Clear();
-                                reexport_module_sp = target.GetImages().FindFirstModule(reexport_module_spec);
-                            }
-                        }
-                        symbol_load_addr = GetSymbolAddress(target, process, sym_ctx.symbol->GetReExportedSymbolName(), symbol_type, reexport_module_sp.get());
-                    }
-                }
-                break;
+  return true;
+}
 
-            case eSymbolTypeData:
-            case eSymbolTypeRuntime:
-            case eSymbolTypeVariable:
-            case eSymbolTypeLocal:
-            case eSymbolTypeParam:
-            case eSymbolTypeInvalid:
-            case eSymbolTypeAbsolute:
-            case eSymbolTypeException:
-            case eSymbolTypeSourceFile:
-            case eSymbolTypeHeaderFile:
-            case eSymbolTypeObjectFile:
-            case eSymbolTypeCommonBlock:
-            case eSymbolTypeBlock:
-            case eSymbolTypeVariableType:
-            case eSymbolTypeLineEntry:
-            case eSymbolTypeLineHeader:
-            case eSymbolTypeScopeBegin:
-            case eSymbolTypeScopeEnd:
-            case eSymbolTypeAdditional:
-            case eSymbolTypeCompiler:
-            case eSymbolTypeInstrumentation:
-            case eSymbolTypeUndefined:
-            case eSymbolTypeObjCClass:
-            case eSymbolTypeObjCMetaClass:
-            case eSymbolTypeObjCIVar:
-                symbol_load_addr = sym_address.GetLoadAddress (&target);
-                break;
+addr_t ClangExpressionDeclMap::GetSymbolAddress(Target &target,
+                                                Process *process,
+                                                const ConstString &name,
+                                                lldb::SymbolType symbol_type,
+                                                lldb_private::Module *module) {
+  SymbolContextList sc_list;
+
+  if (module)
+    module->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
+  else
+    target.GetImages().FindSymbolsWithNameAndType(name, symbol_type, sc_list);
+
+  const uint32_t num_matches = sc_list.GetSize();
+  addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
+
+  for (uint32_t i = 0;
+       i < num_matches &&
+       (symbol_load_addr == 0 || symbol_load_addr == LLDB_INVALID_ADDRESS);
+       i++) {
+    SymbolContext sym_ctx;
+    sc_list.GetContextAtIndex(i, sym_ctx);
+
+    const Address sym_address = sym_ctx.symbol->GetAddress();
+
+    if (!sym_address.IsValid())
+      continue;
+
+    switch (sym_ctx.symbol->GetType()) {
+    case eSymbolTypeCode:
+    case eSymbolTypeTrampoline:
+      symbol_load_addr = sym_address.GetCallableLoadAddress(&target);
+      break;
+
+    case eSymbolTypeResolver:
+      symbol_load_addr = sym_address.GetCallableLoadAddress(&target, true);
+      break;
+
+    case eSymbolTypeReExported: {
+      ConstString reexport_name = sym_ctx.symbol->GetReExportedSymbolName();
+      if (reexport_name) {
+        ModuleSP reexport_module_sp;
+        ModuleSpec reexport_module_spec;
+        reexport_module_spec.GetPlatformFileSpec() =
+            sym_ctx.symbol->GetReExportedSymbolSharedLibrary();
+        if (reexport_module_spec.GetPlatformFileSpec()) {
+          reexport_module_sp =
+              target.GetImages().FindFirstModule(reexport_module_spec);
+          if (!reexport_module_sp) {
+            reexport_module_spec.GetPlatformFileSpec().GetDirectory().Clear();
+            reexport_module_sp =
+                target.GetImages().FindFirstModule(reexport_module_spec);
+          }
         }
+        symbol_load_addr = GetSymbolAddress(
+            target, process, sym_ctx.symbol->GetReExportedSymbolName(),
+            symbol_type, reexport_module_sp.get());
+      }
+    } break;
+
+    case eSymbolTypeData:
+    case eSymbolTypeRuntime:
+    case eSymbolTypeVariable:
+    case eSymbolTypeLocal:
+    case eSymbolTypeParam:
+    case eSymbolTypeInvalid:
+    case eSymbolTypeAbsolute:
+    case eSymbolTypeException:
+    case eSymbolTypeSourceFile:
+    case eSymbolTypeHeaderFile:
+    case eSymbolTypeObjectFile:
+    case eSymbolTypeCommonBlock:
+    case eSymbolTypeBlock:
+    case eSymbolTypeVariableType:
+    case eSymbolTypeLineEntry:
+    case eSymbolTypeLineHeader:
+    case eSymbolTypeScopeBegin:
+    case eSymbolTypeScopeEnd:
+    case eSymbolTypeAdditional:
+    case eSymbolTypeCompiler:
+    case eSymbolTypeInstrumentation:
+    case eSymbolTypeUndefined:
+    case eSymbolTypeObjCClass:
+    case eSymbolTypeObjCMetaClass:
+    case eSymbolTypeObjCIVar:
+      symbol_load_addr = sym_address.GetLoadAddress(&target);
+      break;
     }
+  }
 
-    if (symbol_load_addr == LLDB_INVALID_ADDRESS && process)
-    {
-        ObjCLanguageRuntime *runtime = process->GetObjCLanguageRuntime();
+  if (symbol_load_addr == LLDB_INVALID_ADDRESS && process) {
+    ObjCLanguageRuntime *runtime = process->GetObjCLanguageRuntime();
 
-        if (runtime)
-        {
-            symbol_load_addr = runtime->LookupRuntimeSymbol(name);
-        }
+    if (runtime) {
+      symbol_load_addr = runtime->LookupRuntimeSymbol(name);
     }
+  }
 
-    return symbol_load_addr;
+  return symbol_load_addr;
 }
 
-addr_t
-ClangExpressionDeclMap::GetSymbolAddress (const ConstString &name, lldb::SymbolType symbol_type)
-{
-    assert (m_parser_vars.get());
+addr_t ClangExpressionDeclMap::GetSymbolAddress(const ConstString &name,
+                                                lldb::SymbolType symbol_type) {
+  assert(m_parser_vars.get());
 
-    if (!m_parser_vars->m_exe_ctx.GetTargetPtr())
-        return false;
+  if (!m_parser_vars->m_exe_ctx.GetTargetPtr())
+    return false;
 
-    return GetSymbolAddress(m_parser_vars->m_exe_ctx.GetTargetRef(), m_parser_vars->m_exe_ctx.GetProcessPtr(), name, symbol_type);
+  return GetSymbolAddress(m_parser_vars->m_exe_ctx.GetTargetRef(),
+                          m_parser_vars->m_exe_ctx.GetProcessPtr(), name,
+                          symbol_type);
 }
 
-const Symbol *
-ClangExpressionDeclMap::FindGlobalDataSymbol (Target &target,
-                                              const ConstString &name,
-                                              lldb_private::Module *module)
-{
-    SymbolContextList sc_list;
+const Symbol *ClangExpressionDeclMap::FindGlobalDataSymbol(
+    Target &target, const ConstString &name, lldb_private::Module *module) {
+  SymbolContextList sc_list;
 
-    if (module)
-        module->FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
-    else
-        target.GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
-
-    const uint32_t matches = sc_list.GetSize();
-    for (uint32_t i=0; i<matches; ++i)
-    {
-        SymbolContext sym_ctx;
-        sc_list.GetContextAtIndex(i, sym_ctx);
-        if (sym_ctx.symbol)
-        {
-            const Symbol *symbol = sym_ctx.symbol;
-            const Address sym_address = symbol->GetAddress();
-
-            if (sym_address.IsValid())
-            {
-                switch (symbol->GetType())
-                {
-                    case eSymbolTypeData:
-                    case eSymbolTypeRuntime:
-                    case eSymbolTypeAbsolute:
-                    case eSymbolTypeObjCClass:
-                    case eSymbolTypeObjCMetaClass:
-                    case eSymbolTypeObjCIVar:
-                        if (symbol->GetDemangledNameIsSynthesized())
-                        {
-                            // If the demangled name was synthesized, then don't use it
-                            // for expressions. Only let the symbol match if the mangled
-                            // named matches for these symbols.
-                            if (symbol->GetMangled().GetMangledName() != name)
-                                break;
-                        }
-                        return symbol;
-
-                    case eSymbolTypeReExported:
-                        {
-                            ConstString reexport_name = symbol->GetReExportedSymbolName();
-                            if (reexport_name)
-                            {
-                                ModuleSP reexport_module_sp;
-                                ModuleSpec reexport_module_spec;
-                                reexport_module_spec.GetPlatformFileSpec() = symbol->GetReExportedSymbolSharedLibrary();
-                                if (reexport_module_spec.GetPlatformFileSpec())
-                                {
-                                    reexport_module_sp = target.GetImages().FindFirstModule(reexport_module_spec);
-                                    if (!reexport_module_sp)
-                                    {
-                                        reexport_module_spec.GetPlatformFileSpec().GetDirectory().Clear();
-                                        reexport_module_sp = target.GetImages().FindFirstModule(reexport_module_spec);
-                                    }
-                                }
-                                // Don't allow us to try and resolve a re-exported symbol if it is the same
-                                // as the current symbol
-                                if (name == symbol->GetReExportedSymbolName() && module == reexport_module_sp.get())
-                                    return NULL;
-
-                                return FindGlobalDataSymbol(target, symbol->GetReExportedSymbolName(), reexport_module_sp.get());
-                            }
-                        }
-                        break;
-
-                    case eSymbolTypeCode: // We already lookup functions elsewhere
-                    case eSymbolTypeVariable:
-                    case eSymbolTypeLocal:
-                    case eSymbolTypeParam:
-                    case eSymbolTypeTrampoline:
-                    case eSymbolTypeInvalid:
-                    case eSymbolTypeException:
-                    case eSymbolTypeSourceFile:
-                    case eSymbolTypeHeaderFile:
-                    case eSymbolTypeObjectFile:
-                    case eSymbolTypeCommonBlock:
-                    case eSymbolTypeBlock:
-                    case eSymbolTypeVariableType:
-                    case eSymbolTypeLineEntry:
-                    case eSymbolTypeLineHeader:
-                    case eSymbolTypeScopeBegin:
-                    case eSymbolTypeScopeEnd:
-                    case eSymbolTypeAdditional:
-                    case eSymbolTypeCompiler:
-                    case eSymbolTypeInstrumentation:
-                    case eSymbolTypeUndefined:
-                    case eSymbolTypeResolver:
-                        break;
-                }
+  if (module)
+    module->FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
+  else
+    target.GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeAny,
+                                                  sc_list);
+
+  const uint32_t matches = sc_list.GetSize();
+  for (uint32_t i = 0; i < matches; ++i) {
+    SymbolContext sym_ctx;
+    sc_list.GetContextAtIndex(i, sym_ctx);
+    if (sym_ctx.symbol) {
+      const Symbol *symbol = sym_ctx.symbol;
+      const Address sym_address = symbol->GetAddress();
+
+      if (sym_address.IsValid()) {
+        switch (symbol->GetType()) {
+        case eSymbolTypeData:
+        case eSymbolTypeRuntime:
+        case eSymbolTypeAbsolute:
+        case eSymbolTypeObjCClass:
+        case eSymbolTypeObjCMetaClass:
+        case eSymbolTypeObjCIVar:
+          if (symbol->GetDemangledNameIsSynthesized()) {
+            // If the demangled name was synthesized, then don't use it
+            // for expressions. Only let the symbol match if the mangled
+            // named matches for these symbols.
+            if (symbol->GetMangled().GetMangledName() != name)
+              break;
+          }
+          return symbol;
+
+        case eSymbolTypeReExported: {
+          ConstString reexport_name = symbol->GetReExportedSymbolName();
+          if (reexport_name) {
+            ModuleSP reexport_module_sp;
+            ModuleSpec reexport_module_spec;
+            reexport_module_spec.GetPlatformFileSpec() =
+                symbol->GetReExportedSymbolSharedLibrary();
+            if (reexport_module_spec.GetPlatformFileSpec()) {
+              reexport_module_sp =
+                  target.GetImages().FindFirstModule(reexport_module_spec);
+              if (!reexport_module_sp) {
+                reexport_module_spec.GetPlatformFileSpec()
+                    .GetDirectory()
+                    .Clear();
+                reexport_module_sp =
+                    target.GetImages().FindFirstModule(reexport_module_spec);
+              }
             }
+            // Don't allow us to try and resolve a re-exported symbol if it is
+            // the same
+            // as the current symbol
+            if (name == symbol->GetReExportedSymbolName() &&
+                module == reexport_module_sp.get())
+              return NULL;
+
+            return FindGlobalDataSymbol(target,
+                                        symbol->GetReExportedSymbolName(),
+                                        reexport_module_sp.get());
+          }
+        } break;
+
+        case eSymbolTypeCode: // We already lookup functions elsewhere
+        case eSymbolTypeVariable:
+        case eSymbolTypeLocal:
+        case eSymbolTypeParam:
+        case eSymbolTypeTrampoline:
+        case eSymbolTypeInvalid:
+        case eSymbolTypeException:
+        case eSymbolTypeSourceFile:
+        case eSymbolTypeHeaderFile:
+        case eSymbolTypeObjectFile:
+        case eSymbolTypeCommonBlock:
+        case eSymbolTypeBlock:
+        case eSymbolTypeVariableType:
+        case eSymbolTypeLineEntry:
+        case eSymbolTypeLineHeader:
+        case eSymbolTypeScopeBegin:
+        case eSymbolTypeScopeEnd:
+        case eSymbolTypeAdditional:
+        case eSymbolTypeCompiler:
+        case eSymbolTypeInstrumentation:
+        case eSymbolTypeUndefined:
+        case eSymbolTypeResolver:
+          break;
         }
+      }
     }
+  }
 
-    return NULL;
+  return NULL;
 }
 
-lldb::VariableSP
-ClangExpressionDeclMap::FindGlobalVariable
-(
-    Target &target,
-    ModuleSP &module,
-    const ConstString &name,
-    CompilerDeclContext *namespace_decl,
-    TypeFromUser *type
-)
-{
-    VariableList vars;
-
-    if (module && namespace_decl)
-        module->FindGlobalVariables (name, namespace_decl, true, -1, vars);
-    else
-        target.GetImages().FindGlobalVariables(name, true, -1, vars);
-
-    if (vars.GetSize())
-    {
-        if (type)
-        {
-            for (size_t i = 0; i < vars.GetSize(); ++i)
-            {
-                VariableSP var_sp = vars.GetVariableAtIndex(i);
-
-                if (ClangASTContext::AreTypesSame(*type, var_sp->GetType()->GetFullCompilerType ()))
-                    return var_sp;
-            }
-        }
-        else
-        {
-            return vars.GetVariableAtIndex(0);
-        }
+lldb::VariableSP ClangExpressionDeclMap::FindGlobalVariable(
+    Target &target, ModuleSP &module, const ConstString &name,
+    CompilerDeclContext *namespace_decl, TypeFromUser *type) {
+  VariableList vars;
+
+  if (module && namespace_decl)
+    module->FindGlobalVariables(name, namespace_decl, true, -1, vars);
+  else
+    target.GetImages().FindGlobalVariables(name, true, -1, vars);
+
+  if (vars.GetSize()) {
+    if (type) {
+      for (size_t i = 0; i < vars.GetSize(); ++i) {
+        VariableSP var_sp = vars.GetVariableAtIndex(i);
+
+        if (ClangASTContext::AreTypesSame(
+                *type, var_sp->GetType()->GetFullCompilerType()))
+          return var_sp;
+      }
+    } else {
+      return vars.GetVariableAtIndex(0);
     }
+  }
 
-    return VariableSP();
+  return VariableSP();
 }
 
-ClangASTContext *
-ClangExpressionDeclMap::GetClangASTContext ()
-{
-    StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
-    if (frame == nullptr)
-        return nullptr;
+ClangASTContext *ClangExpressionDeclMap::GetClangASTContext() {
+  StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
+  if (frame == nullptr)
+    return nullptr;
 
-    SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction|lldb::eSymbolContextBlock);
-    if (sym_ctx.block == nullptr)
-        return nullptr;
+  SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
+                                                  lldb::eSymbolContextBlock);
+  if (sym_ctx.block == nullptr)
+    return nullptr;
 
-    CompilerDeclContext frame_decl_context = sym_ctx.block->GetDeclContext();
-    if (!frame_decl_context)
-        return nullptr;
+  CompilerDeclContext frame_decl_context = sym_ctx.block->GetDeclContext();
+  if (!frame_decl_context)
+    return nullptr;
 
-    return llvm::dyn_cast_or_null<ClangASTContext>(frame_decl_context.GetTypeSystem());
+  return llvm::dyn_cast_or_null<ClangASTContext>(
+      frame_decl_context.GetTypeSystem());
 }
 
 // Interface for ClangASTSource
 
-void
-ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context)
-{
-    assert (m_ast_context);
+void ClangExpressionDeclMap::FindExternalVisibleDecls(
+    NameSearchContext &context) {
+  assert(m_ast_context);
 
-    ClangASTMetrics::RegisterVisibleQuery();
+  ClangASTMetrics::RegisterVisibleQuery();
 
-    const ConstString name(context.m_decl_name.getAsString().c_str());
+  const ConstString name(context.m_decl_name.getAsString().c_str());
 
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    if (GetImportInProgress())
-    {
-        if (log && log->GetVerbose())
-            log->Printf("Ignoring a query during an import");
-        return;
+  if (GetImportInProgress()) {
+    if (log && log->GetVerbose())
+      log->Printf("Ignoring a query during an import");
+    return;
+  }
+
+  static unsigned int invocation_id = 0;
+  unsigned int current_id = invocation_id++;
+
+  if (log) {
+    if (!context.m_decl_context)
+      log->Printf("ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for "
+                  "'%s' in a NULL DeclContext",
+                  current_id, name.GetCString());
+    else if (const NamedDecl *context_named_decl =
+                 dyn_cast<NamedDecl>(context.m_decl_context))
+      log->Printf("ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for "
+                  "'%s' in '%s'",
+                  current_id, name.GetCString(),
+                  context_named_decl->getNameAsString().c_str());
+    else
+      log->Printf("ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for "
+                  "'%s' in a '%s'",
+                  current_id, name.GetCString(),
+                  context.m_decl_context->getDeclKindName());
+  }
+
+  if (const NamespaceDecl *namespace_context =
+          dyn_cast<NamespaceDecl>(context.m_decl_context)) {
+    if (namespace_context->getName().str() ==
+        std::string(g_lldb_local_vars_namespace_cstr)) {
+      CompilerDeclContext compiler_decl_ctx(
+          GetClangASTContext(), const_cast<void *>(static_cast<const void *>(
+                                    context.m_decl_context)));
+      FindExternalVisibleDecls(context, lldb::ModuleSP(), compiler_decl_ctx,
+                               current_id);
+      return;
     }
 
-    static unsigned int invocation_id = 0;
-    unsigned int current_id = invocation_id++;
+    ClangASTImporter::NamespaceMapSP namespace_map =
+        m_ast_importer_sp->GetNamespaceMap(namespace_context);
 
-    if (log)
-    {
-        if (!context.m_decl_context)
-            log->Printf("ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for '%s' in a NULL DeclContext", current_id, name.GetCString());
-        else if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context.m_decl_context))
-            log->Printf("ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for '%s' in '%s'", current_id, name.GetCString(), context_named_decl->getNameAsString().c_str());
-        else
-            log->Printf("ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for '%s' in a '%s'", current_id, name.GetCString(), context.m_decl_context->getDeclKindName());
+    if (log && log->GetVerbose())
+      log->Printf("  CEDM::FEVD[%u] Inspecting (NamespaceMap*)%p (%d entries)",
+                  current_id, static_cast<void *>(namespace_map.get()),
+                  (int)namespace_map->size());
+
+    if (!namespace_map)
+      return;
+
+    for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(),
+                                                  e = namespace_map->end();
+         i != e; ++i) {
+      if (log)
+        log->Printf("  CEDM::FEVD[%u] Searching namespace %s in module %s",
+                    current_id, i->second.GetName().AsCString(),
+                    i->first->GetFileSpec().GetFilename().GetCString());
+
+      FindExternalVisibleDecls(context, i->first, i->second, current_id);
     }
+  } else if (isa<TranslationUnitDecl>(context.m_decl_context)) {
+    CompilerDeclContext namespace_decl;
 
-    if (const NamespaceDecl *namespace_context = dyn_cast<NamespaceDecl>(context.m_decl_context))
-    {
-        if (namespace_context->getName().str() == std::string(g_lldb_local_vars_namespace_cstr))
-        {
-            CompilerDeclContext compiler_decl_ctx(GetClangASTContext(), const_cast<void *>(static_cast<const void *>(context.m_decl_context)));
-            FindExternalVisibleDecls(context, lldb::ModuleSP(), compiler_decl_ctx, current_id);
-            return;
-        }
+    if (log)
+      log->Printf("  CEDM::FEVD[%u] Searching the root namespace", current_id);
 
-        ClangASTImporter::NamespaceMapSP namespace_map = m_ast_importer_sp->GetNamespaceMap(namespace_context);
+    FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl,
+                             current_id);
+  }
 
-        if (log && log->GetVerbose())
-            log->Printf("  CEDM::FEVD[%u] Inspecting (NamespaceMap*)%p (%d entries)",
-                        current_id, static_cast<void*>(namespace_map.get()),
-                        (int)namespace_map->size());
+  if (!context.m_found.variable && !context.m_found.local_vars_nsp)
+    ClangASTSource::FindExternalVisibleDecls(context);
+}
 
-        if (!namespace_map)
-            return;
+void ClangExpressionDeclMap::FindExternalVisibleDecls(
+    NameSearchContext &context, lldb::ModuleSP module_sp,
+    CompilerDeclContext &namespace_decl, unsigned int current_id) {
+  assert(m_ast_context);
 
-        for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(), e = namespace_map->end();
-             i != e;
-             ++i)
-        {
-            if (log)
-                log->Printf("  CEDM::FEVD[%u] Searching namespace %s in module %s",
-                            current_id,
-                            i->second.GetName().AsCString(),
-                            i->first->GetFileSpec().GetFilename().GetCString());
-
-            FindExternalVisibleDecls(context,
-                                     i->first,
-                                     i->second,
-                                     current_id);
+  std::function<void(clang::FunctionDecl *)> MaybeRegisterFunctionBody =
+      [this](clang::FunctionDecl *copied_function_decl) {
+        if (copied_function_decl->getBody() && m_parser_vars->m_code_gen) {
+          DeclGroupRef decl_group_ref(copied_function_decl);
+          m_parser_vars->m_code_gen->HandleTopLevelDecl(decl_group_ref);
         }
-    }
-    else if (isa<TranslationUnitDecl>(context.m_decl_context))
-    {
-        CompilerDeclContext namespace_decl;
+      };
 
-        if (log)
-            log->Printf("  CEDM::FEVD[%u] Searching the root namespace", current_id);
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-        FindExternalVisibleDecls(context,
-                                 lldb::ModuleSP(),
-                                 namespace_decl,
-                                 current_id);
-    }
+  SymbolContextList sc_list;
 
-    if (!context.m_found.variable && !context.m_found.local_vars_nsp)
-        ClangASTSource::FindExternalVisibleDecls(context);
-}
+  const ConstString name(context.m_decl_name.getAsString().c_str());
 
-void
-ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context,
-                                                  lldb::ModuleSP module_sp,
-                                                  CompilerDeclContext &namespace_decl,
-                                                  unsigned int current_id)
-{
-    assert (m_ast_context);
-    
-    std::function<void (clang::FunctionDecl *)> MaybeRegisterFunctionBody =
-    [this](clang::FunctionDecl *copied_function_decl)
-    {
-        if (copied_function_decl->getBody() && m_parser_vars->m_code_gen)
-        {
-            DeclGroupRef decl_group_ref(copied_function_decl);
-            m_parser_vars->m_code_gen->HandleTopLevelDecl(decl_group_ref);
-        }
-    };
+  const char *name_unique_cstr = name.GetCString();
+
+  if (name_unique_cstr == NULL)
+    return;
 
+  static ConstString id_name("id");
+  static ConstString Class_name("Class");
 
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+  if (name == id_name || name == Class_name)
+    return;
 
-    SymbolContextList sc_list;
+  // Only look for functions by name out in our symbols if the function
+  // doesn't start with our phony prefix of '$'
+  Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
+  StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
+  SymbolContext sym_ctx;
+  if (frame != nullptr)
+    sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
+                                      lldb::eSymbolContextBlock);
 
-    const ConstString name(context.m_decl_name.getAsString().c_str());
+  // Try the persistent decls, which take precedence over all else.
+  if (!namespace_decl) {
+    do {
+      if (!target)
+        break;
 
-    const char *name_unique_cstr = name.GetCString();
+      ClangASTContext *scratch_clang_ast_context =
+          target->GetScratchClangASTContext();
 
-    if (name_unique_cstr == NULL)
-        return;
+      if (!scratch_clang_ast_context)
+        break;
 
-    static ConstString id_name("id");
-    static ConstString Class_name("Class");
+      ASTContext *scratch_ast_context =
+          scratch_clang_ast_context->getASTContext();
 
-    if (name == id_name || name == Class_name)
-        return;
+      if (!scratch_ast_context)
+        break;
 
-    // Only look for functions by name out in our symbols if the function
-    // doesn't start with our phony prefix of '$'
-    Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
-    StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
-    SymbolContext sym_ctx;
-    if (frame != nullptr)
-        sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction|lldb::eSymbolContextBlock);
-    
-    // Try the persistent decls, which take precedence over all else.
-    if (!namespace_decl)
-    {
-        do
-        {
-            if (!target)
-                break;
-            
-            ClangASTContext *scratch_clang_ast_context = target->GetScratchClangASTContext();
-            
-            if (!scratch_clang_ast_context)
-                break;
-            
-            ASTContext *scratch_ast_context = scratch_clang_ast_context->getASTContext();
-            
-            if (!scratch_ast_context)
-                break;
-            
-            NamedDecl *persistent_decl = m_parser_vars->m_persistent_vars->GetPersistentDecl(name);
-            
-            if (!persistent_decl)
-                break;
-            
-            Decl *parser_persistent_decl = m_ast_importer_sp->CopyDecl(m_ast_context, scratch_ast_context, persistent_decl);
-            
-            if (!parser_persistent_decl)
-                break;
-            
-            NamedDecl *parser_named_decl = dyn_cast<NamedDecl>(parser_persistent_decl);
-            
-            if (!parser_named_decl)
-                break;
-            
-            if (clang::FunctionDecl *parser_function_decl = llvm::dyn_cast<clang::FunctionDecl>(parser_named_decl))
-            {
-                MaybeRegisterFunctionBody(parser_function_decl);
-            }
-            
-            if (log)
-                log->Printf("  CEDM::FEVD[%u] Found persistent decl %s", current_id, name.GetCString());
-            
-            context.AddNamedDecl(parser_named_decl);
-        } while (0);
-    }
-    
-    if (name_unique_cstr[0] == '$' && !namespace_decl)
-    {
-        static ConstString g_lldb_class_name ("$__lldb_class");
+      NamedDecl *persistent_decl =
+          m_parser_vars->m_persistent_vars->GetPersistentDecl(name);
 
-        if (name == g_lldb_class_name)
-        {
-            // Clang is looking for the type of "this"
+      if (!persistent_decl)
+        break;
 
-            if (frame == NULL)
-                return;
+      Decl *parser_persistent_decl = m_ast_importer_sp->CopyDecl(
+          m_ast_context, scratch_ast_context, persistent_decl);
 
+      if (!parser_persistent_decl)
+        break;
 
-            // Find the block that defines the function represented by "sym_ctx"
-            Block *function_block = sym_ctx.GetFunctionBlock();
+      NamedDecl *parser_named_decl =
+          dyn_cast<NamedDecl>(parser_persistent_decl);
 
-            if (!function_block)
-                return;
+      if (!parser_named_decl)
+        break;
 
-            CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
+      if (clang::FunctionDecl *parser_function_decl =
+              llvm::dyn_cast<clang::FunctionDecl>(parser_named_decl)) {
+        MaybeRegisterFunctionBody(parser_function_decl);
+      }
 
-            if (!function_decl_ctx)
-                return;
+      if (log)
+        log->Printf("  CEDM::FEVD[%u] Found persistent decl %s", current_id,
+                    name.GetCString());
 
-            clang::CXXMethodDecl *method_decl = ClangASTContext::DeclContextGetAsCXXMethodDecl(function_decl_ctx);
+      context.AddNamedDecl(parser_named_decl);
+    } while (0);
+  }
 
-            if (method_decl)
-            {
-                clang::CXXRecordDecl *class_decl = method_decl->getParent();
+  if (name_unique_cstr[0] == '$' && !namespace_decl) {
+    static ConstString g_lldb_class_name("$__lldb_class");
 
-                QualType class_qual_type(class_decl->getTypeForDecl(), 0);
+    if (name == g_lldb_class_name) {
+      // Clang is looking for the type of "this"
 
-                TypeFromUser class_user_type (class_qual_type.getAsOpaquePtr(),
-                                              ClangASTContext::GetASTContext(&class_decl->getASTContext()));
+      if (frame == NULL)
+        return;
 
-                if (log)
-                {
-                    ASTDumper ast_dumper(class_qual_type);
-                    log->Printf("  CEDM::FEVD[%u] Adding type for $__lldb_class: %s", current_id, ast_dumper.GetCString());
-                }
+      // Find the block that defines the function represented by "sym_ctx"
+      Block *function_block = sym_ctx.GetFunctionBlock();
 
-                AddThisType(context, class_user_type, current_id);
+      if (!function_block)
+        return;
 
-                if (method_decl->isInstance())
-                {
-                    // self is a pointer to the object
+      CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
 
-                    QualType class_pointer_type = method_decl->getASTContext().getPointerType(class_qual_type);
+      if (!function_decl_ctx)
+        return;
 
-                    TypeFromUser self_user_type(class_pointer_type.getAsOpaquePtr(),
-                                                ClangASTContext::GetASTContext(&method_decl->getASTContext()));
+      clang::CXXMethodDecl *method_decl =
+          ClangASTContext::DeclContextGetAsCXXMethodDecl(function_decl_ctx);
 
-                    m_struct_vars->m_object_pointer_type = self_user_type;
-                }
-            }
-            else
-            {
-                // This branch will get hit if we are executing code in the context of a function that
-                // claims to have an object pointer (through DW_AT_object_pointer?) but is not formally a
-                // method of the class.  In that case, just look up the "this" variable in the current
-                // scope and use its type.
-                // FIXME: This code is formally correct, but clang doesn't currently emit DW_AT_object_pointer
-                // for C++ so it hasn't actually been tested.
-
-                VariableList *vars = frame->GetVariableList(false);
-
-                lldb::VariableSP this_var = vars->FindVariable(ConstString("this"));
-
-                if (this_var &&
-                    this_var->IsInScope(frame) &&
-                    this_var->LocationIsValidForFrame (frame))
-                {
-                    Type *this_type = this_var->GetType();
-
-                    if (!this_type)
-                        return;
-
-                    TypeFromUser pointee_type = this_type->GetForwardCompilerType ().GetPointeeType();
-
-                    if (pointee_type.IsValid())
-                    {
-                        if (log)
-                        {
-                            ASTDumper ast_dumper(pointee_type);
-                            log->Printf("  FEVD[%u] Adding type for $__lldb_class: %s", current_id, ast_dumper.GetCString());
-                        }
-                        
-                        AddThisType(context, pointee_type, current_id);
-                        TypeFromUser this_user_type(this_type->GetFullCompilerType ());
-                        m_struct_vars->m_object_pointer_type = this_user_type;
-                        return;
-                    }
-                }
+      if (method_decl) {
+        clang::CXXRecordDecl *class_decl = method_decl->getParent();
+
+        QualType class_qual_type(class_decl->getTypeForDecl(), 0);
+
+        TypeFromUser class_user_type(
+            class_qual_type.getAsOpaquePtr(),
+            ClangASTContext::GetASTContext(&class_decl->getASTContext()));
+
+        if (log) {
+          ASTDumper ast_dumper(class_qual_type);
+          log->Printf("  CEDM::FEVD[%u] Adding type for $__lldb_class: %s",
+                      current_id, ast_dumper.GetCString());
+        }
+
+        AddThisType(context, class_user_type, current_id);
+
+        if (method_decl->isInstance()) {
+          // self is a pointer to the object
+
+          QualType class_pointer_type =
+              method_decl->getASTContext().getPointerType(class_qual_type);
+
+          TypeFromUser self_user_type(
+              class_pointer_type.getAsOpaquePtr(),
+              ClangASTContext::GetASTContext(&method_decl->getASTContext()));
+
+          m_struct_vars->m_object_pointer_type = self_user_type;
+        }
+      } else {
+        // This branch will get hit if we are executing code in the context of a
+        // function that
+        // claims to have an object pointer (through DW_AT_object_pointer?) but
+        // is not formally a
+        // method of the class.  In that case, just look up the "this" variable
+        // in the current
+        // scope and use its type.
+        // FIXME: This code is formally correct, but clang doesn't currently
+        // emit DW_AT_object_pointer
+        // for C++ so it hasn't actually been tested.
+
+        VariableList *vars = frame->GetVariableList(false);
+
+        lldb::VariableSP this_var = vars->FindVariable(ConstString("this"));
+
+        if (this_var && this_var->IsInScope(frame) &&
+            this_var->LocationIsValidForFrame(frame)) {
+          Type *this_type = this_var->GetType();
+
+          if (!this_type)
+            return;
+
+          TypeFromUser pointee_type =
+              this_type->GetForwardCompilerType().GetPointeeType();
+
+          if (pointee_type.IsValid()) {
+            if (log) {
+              ASTDumper ast_dumper(pointee_type);
+              log->Printf("  FEVD[%u] Adding type for $__lldb_class: %s",
+                          current_id, ast_dumper.GetCString());
             }
 
+            AddThisType(context, pointee_type, current_id);
+            TypeFromUser this_user_type(this_type->GetFullCompilerType());
+            m_struct_vars->m_object_pointer_type = this_user_type;
             return;
+          }
         }
+      }
 
-        static ConstString g_lldb_objc_class_name ("$__lldb_objc_class");
-        if (name == g_lldb_objc_class_name)
-        {
-            // Clang is looking for the type of "*self"
+      return;
+    }
 
-            if (!frame)
-                return;
+    static ConstString g_lldb_objc_class_name("$__lldb_objc_class");
+    if (name == g_lldb_objc_class_name) {
+      // Clang is looking for the type of "*self"
 
-            SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction|lldb::eSymbolContextBlock);
+      if (!frame)
+        return;
 
-            // Find the block that defines the function represented by "sym_ctx"
-            Block *function_block = sym_ctx.GetFunctionBlock();
+      SymbolContext sym_ctx = frame->GetSymbolContext(
+          lldb::eSymbolContextFunction | lldb::eSymbolContextBlock);
 
-            if (!function_block)
-                return;
+      // Find the block that defines the function represented by "sym_ctx"
+      Block *function_block = sym_ctx.GetFunctionBlock();
 
-            CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
+      if (!function_block)
+        return;
 
-            if (!function_decl_ctx)
-                return;
+      CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
 
-            clang::ObjCMethodDecl *method_decl = ClangASTContext::DeclContextGetAsObjCMethodDecl(function_decl_ctx);
+      if (!function_decl_ctx)
+        return;
 
-            if (method_decl)
-            {
-                ObjCInterfaceDecl* self_interface = method_decl->getClassInterface();
+      clang::ObjCMethodDecl *method_decl =
+          ClangASTContext::DeclContextGetAsObjCMethodDecl(function_decl_ctx);
 
-                if (!self_interface)
-                    return;
+      if (method_decl) {
+        ObjCInterfaceDecl *self_interface = method_decl->getClassInterface();
 
-                const clang::Type *interface_type = self_interface->getTypeForDecl();
+        if (!self_interface)
+          return;
 
-                if (!interface_type)
-                    return; // This is unlikely, but we have seen crashes where this occurred
+        const clang::Type *interface_type = self_interface->getTypeForDecl();
 
-                TypeFromUser class_user_type(QualType(interface_type, 0).getAsOpaquePtr(),
-                                             ClangASTContext::GetASTContext(&method_decl->getASTContext()));
+        if (!interface_type)
+          return; // This is unlikely, but we have seen crashes where this
+                  // occurred
 
-                if (log)
-                {
-                    ASTDumper ast_dumper(interface_type);
-                    log->Printf("  FEVD[%u] Adding type for $__lldb_objc_class: %s", current_id, ast_dumper.GetCString());
-                }
+        TypeFromUser class_user_type(
+            QualType(interface_type, 0).getAsOpaquePtr(),
+            ClangASTContext::GetASTContext(&method_decl->getASTContext()));
 
-                AddOneType(context, class_user_type, current_id);
+        if (log) {
+          ASTDumper ast_dumper(interface_type);
+          log->Printf("  FEVD[%u] Adding type for $__lldb_objc_class: %s",
+                      current_id, ast_dumper.GetCString());
+        }
 
-                if (method_decl->isInstanceMethod())
-                {
-                    // self is a pointer to the object
+        AddOneType(context, class_user_type, current_id);
 
-                    QualType class_pointer_type = method_decl->getASTContext().getObjCObjectPointerType(QualType(interface_type, 0));
+        if (method_decl->isInstanceMethod()) {
+          // self is a pointer to the object
 
-                    TypeFromUser self_user_type(class_pointer_type.getAsOpaquePtr(),
-                                                ClangASTContext::GetASTContext(&method_decl->getASTContext()));
+          QualType class_pointer_type =
+              method_decl->getASTContext().getObjCObjectPointerType(
+                  QualType(interface_type, 0));
 
-                    m_struct_vars->m_object_pointer_type = self_user_type;
-                }
-                else
-                {
-                    // self is a Class pointer
-                    QualType class_type = method_decl->getASTContext().getObjCClassType();
+          TypeFromUser self_user_type(
+              class_pointer_type.getAsOpaquePtr(),
+              ClangASTContext::GetASTContext(&method_decl->getASTContext()));
 
-                    TypeFromUser self_user_type(class_type.getAsOpaquePtr(),
-                                                ClangASTContext::GetASTContext(&method_decl->getASTContext()));
+          m_struct_vars->m_object_pointer_type = self_user_type;
+        } else {
+          // self is a Class pointer
+          QualType class_type = method_decl->getASTContext().getObjCClassType();
 
-                    m_struct_vars->m_object_pointer_type = self_user_type;
-                }
+          TypeFromUser self_user_type(
+              class_type.getAsOpaquePtr(),
+              ClangASTContext::GetASTContext(&method_decl->getASTContext()));
 
-                return;
-            }
-            else
-            {
-                // This branch will get hit if we are executing code in the context of a function that
-                // claims to have an object pointer (through DW_AT_object_pointer?) but is not formally a
-                // method of the class.  In that case, just look up the "self" variable in the current
-                // scope and use its type.
+          m_struct_vars->m_object_pointer_type = self_user_type;
+        }
 
-                VariableList *vars = frame->GetVariableList(false);
+        return;
+      } else {
+        // This branch will get hit if we are executing code in the context of a
+        // function that
+        // claims to have an object pointer (through DW_AT_object_pointer?) but
+        // is not formally a
+        // method of the class.  In that case, just look up the "self" variable
+        // in the current
+        // scope and use its type.
 
-                lldb::VariableSP self_var = vars->FindVariable(ConstString("self"));
+        VariableList *vars = frame->GetVariableList(false);
 
-                if (self_var &&
-                    self_var->IsInScope(frame) &&
-                    self_var->LocationIsValidForFrame (frame))
-                {
-                    Type *self_type = self_var->GetType();
+        lldb::VariableSP self_var = vars->FindVariable(ConstString("self"));
 
-                    if (!self_type)
-                        return;
+        if (self_var && self_var->IsInScope(frame) &&
+            self_var->LocationIsValidForFrame(frame)) {
+          Type *self_type = self_var->GetType();
 
-                    CompilerType self_clang_type = self_type->GetFullCompilerType ();
+          if (!self_type)
+            return;
 
-                    if (ClangASTContext::IsObjCClassType(self_clang_type))
-                    {
-                        return;
-                    }
-                    else if (ClangASTContext::IsObjCObjectPointerType(self_clang_type))
-                    {
-                        self_clang_type = self_clang_type.GetPointeeType();
+          CompilerType self_clang_type = self_type->GetFullCompilerType();
 
-                        if (!self_clang_type)
-                            return;
+          if (ClangASTContext::IsObjCClassType(self_clang_type)) {
+            return;
+          } else if (ClangASTContext::IsObjCObjectPointerType(
+                         self_clang_type)) {
+            self_clang_type = self_clang_type.GetPointeeType();
 
-                        if (log)
-                        {
-                            ASTDumper ast_dumper(self_type->GetFullCompilerType ());
-                            log->Printf("  FEVD[%u] Adding type for $__lldb_objc_class: %s", current_id, ast_dumper.GetCString());
-                        }
+            if (!self_clang_type)
+              return;
 
-                        TypeFromUser class_user_type (self_clang_type);
+            if (log) {
+              ASTDumper ast_dumper(self_type->GetFullCompilerType());
+              log->Printf("  FEVD[%u] Adding type for $__lldb_objc_class: %s",
+                          current_id, ast_dumper.GetCString());
+            }
 
-                        AddOneType(context, class_user_type, current_id);
+            TypeFromUser class_user_type(self_clang_type);
 
-                        TypeFromUser self_user_type(self_type->GetFullCompilerType ());
+            AddOneType(context, class_user_type, current_id);
 
-                        m_struct_vars->m_object_pointer_type = self_user_type;
-                        return;
-                    }
-                }
-            }
+            TypeFromUser self_user_type(self_type->GetFullCompilerType());
 
+            m_struct_vars->m_object_pointer_type = self_user_type;
             return;
+          }
         }
+      }
 
-        if (name == ConstString(g_lldb_local_vars_namespace_cstr))
-        {
-            CompilerDeclContext frame_decl_context = sym_ctx.block != nullptr ?
-                                                     sym_ctx.block->GetDeclContext() :
-                                                     CompilerDeclContext();
-
-            if (frame_decl_context)
-            {
-                ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(frame_decl_context.GetTypeSystem());
-
-                if (ast)
-                {
-                    clang::NamespaceDecl *namespace_decl = ClangASTContext::GetUniqueNamespaceDeclaration(
-                        m_ast_context, name_unique_cstr, nullptr);
-                    if (namespace_decl)
-                    {
-                        context.AddNamedDecl(namespace_decl);
-                        clang::DeclContext *clang_decl_ctx = clang::Decl::castToDeclContext(namespace_decl);
-                        clang_decl_ctx->setHasExternalVisibleStorage(true);
-                        context.m_found.local_vars_nsp = true;
-                    }
-                }
-            }
+      return;
+    }
 
-            return;
+    if (name == ConstString(g_lldb_local_vars_namespace_cstr)) {
+      CompilerDeclContext frame_decl_context =
+          sym_ctx.block != nullptr ? sym_ctx.block->GetDeclContext()
+                                   : CompilerDeclContext();
+
+      if (frame_decl_context) {
+        ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(
+            frame_decl_context.GetTypeSystem());
+
+        if (ast) {
+          clang::NamespaceDecl *namespace_decl =
+              ClangASTContext::GetUniqueNamespaceDeclaration(
+                  m_ast_context, name_unique_cstr, nullptr);
+          if (namespace_decl) {
+            context.AddNamedDecl(namespace_decl);
+            clang::DeclContext *clang_decl_ctx =
+                clang::Decl::castToDeclContext(namespace_decl);
+            clang_decl_ctx->setHasExternalVisibleStorage(true);
+            context.m_found.local_vars_nsp = true;
+          }
         }
+      }
 
-        // any other $__lldb names should be weeded out now
-        if (!::strncmp(name_unique_cstr, "$__lldb", sizeof("$__lldb") - 1))
-            return;
+      return;
+    }
 
-        ExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariable(name));
+    // any other $__lldb names should be weeded out now
+    if (!::strncmp(name_unique_cstr, "$__lldb", sizeof("$__lldb") - 1))
+      return;
 
-        if (pvar_sp)
-        {
-            AddOneVariable(context, pvar_sp, current_id);
-            return;
-        }
+    ExpressionVariableSP pvar_sp(
+        m_parser_vars->m_persistent_vars->GetVariable(name));
 
-        const char *reg_name(&name.GetCString()[1]);
+    if (pvar_sp) {
+      AddOneVariable(context, pvar_sp, current_id);
+      return;
+    }
 
-        if (m_parser_vars->m_exe_ctx.GetRegisterContext())
-        {
-            const RegisterInfo *reg_info(m_parser_vars->m_exe_ctx.GetRegisterContext()->GetRegisterInfoByName(reg_name));
+    const char *reg_name(&name.GetCString()[1]);
 
-            if (reg_info)
-            {
-                if (log)
-                    log->Printf("  CEDM::FEVD[%u] Found register %s", current_id, reg_info->name);
+    if (m_parser_vars->m_exe_ctx.GetRegisterContext()) {
+      const RegisterInfo *reg_info(
+          m_parser_vars->m_exe_ctx.GetRegisterContext()->GetRegisterInfoByName(
+              reg_name));
 
-                AddOneRegister(context, reg_info, current_id);
-            }
-        }
+      if (reg_info) {
+        if (log)
+          log->Printf("  CEDM::FEVD[%u] Found register %s", current_id,
+                      reg_info->name);
+
+        AddOneRegister(context, reg_info, current_id);
+      }
     }
-    else
-    {
-        ValueObjectSP valobj;
-        VariableSP var;
-
-        bool local_var_lookup = !namespace_decl ||
-                                (namespace_decl.GetName() == ConstString(g_lldb_local_vars_namespace_cstr));
-        if (frame && local_var_lookup)
-        {
-            CompilerDeclContext compiler_decl_context = sym_ctx.block != nullptr ? sym_ctx.block->GetDeclContext() : CompilerDeclContext();
-
-            if (compiler_decl_context)
-            {
-                // Make sure that the variables are parsed so that we have the declarations.
-                VariableListSP vars = frame->GetInScopeVariableList(true);
-                for (size_t i = 0; i < vars->GetSize(); i++)
-                    vars->GetVariableAtIndex(i)->GetDecl();
-
-                // Search for declarations matching the name. Do not include imported decls
-                // in the search if we are looking for decls in the artificial namespace
-                // $__lldb_local_vars.
-                std::vector<CompilerDecl> found_decls = compiler_decl_context.FindDeclByName(name, namespace_decl.IsValid());
-                
-                bool variable_found = false;
-                for (CompilerDecl decl : found_decls)
-                {
-                    for (size_t vi = 0, ve = vars->GetSize(); vi != ve; ++vi)
-                    {
-                        VariableSP candidate_var = vars->GetVariableAtIndex(vi);
-                        if (candidate_var->GetDecl() == decl)
-                        {
-                            var = candidate_var;
-                            break;
-                        }
-                    }
-
-                    if (var)
-                    {
-                        variable_found = true;
-                        valobj = ValueObjectVariable::Create(frame, var);
-                        AddOneVariable(context, var, valobj, current_id);
-                        context.m_found.variable = true;
-                    }
-                }
-                if (variable_found)
-                    return;
+  } else {
+    ValueObjectSP valobj;
+    VariableSP var;
+
+    bool local_var_lookup =
+        !namespace_decl || (namespace_decl.GetName() ==
+                            ConstString(g_lldb_local_vars_namespace_cstr));
+    if (frame && local_var_lookup) {
+      CompilerDeclContext compiler_decl_context =
+          sym_ctx.block != nullptr ? sym_ctx.block->GetDeclContext()
+                                   : CompilerDeclContext();
+
+      if (compiler_decl_context) {
+        // Make sure that the variables are parsed so that we have the
+        // declarations.
+        VariableListSP vars = frame->GetInScopeVariableList(true);
+        for (size_t i = 0; i < vars->GetSize(); i++)
+          vars->GetVariableAtIndex(i)->GetDecl();
+
+        // Search for declarations matching the name. Do not include imported
+        // decls
+        // in the search if we are looking for decls in the artificial namespace
+        // $__lldb_local_vars.
+        std::vector<CompilerDecl> found_decls =
+            compiler_decl_context.FindDeclByName(name,
+                                                 namespace_decl.IsValid());
+
+        bool variable_found = false;
+        for (CompilerDecl decl : found_decls) {
+          for (size_t vi = 0, ve = vars->GetSize(); vi != ve; ++vi) {
+            VariableSP candidate_var = vars->GetVariableAtIndex(vi);
+            if (candidate_var->GetDecl() == decl) {
+              var = candidate_var;
+              break;
             }
+          }
+
+          if (var) {
+            variable_found = true;
+            valobj = ValueObjectVariable::Create(frame, var);
+            AddOneVariable(context, var, valobj, current_id);
+            context.m_found.variable = true;
+          }
         }
-        if (target)
-        {
-            var = FindGlobalVariable (*target,
-                                      module_sp,
-                                      name,
-                                      &namespace_decl,
-                                      NULL);
-
-            if (var)
-            {
-                valobj = ValueObjectVariable::Create(target, var);
-                AddOneVariable(context, var, valobj, current_id);
-                context.m_found.variable = true;
-                return;
+        if (variable_found)
+          return;
+      }
+    }
+    if (target) {
+      var = FindGlobalVariable(*target, module_sp, name, &namespace_decl, NULL);
+
+      if (var) {
+        valobj = ValueObjectVariable::Create(target, var);
+        AddOneVariable(context, var, valobj, current_id);
+        context.m_found.variable = true;
+        return;
+      }
+    }
+
+    std::vector<clang::NamedDecl *> decls_from_modules;
+
+    if (target) {
+      if (ClangModulesDeclVendor *decl_vendor =
+              target->GetClangModulesDeclVendor()) {
+        decl_vendor->FindDecls(name, false, UINT32_MAX, decls_from_modules);
+      }
+    }
+
+    if (!context.m_found.variable) {
+      const bool include_inlines = false;
+      const bool append = false;
+
+      if (namespace_decl && module_sp) {
+        const bool include_symbols = false;
+
+        module_sp->FindFunctions(name, &namespace_decl, eFunctionNameTypeBase,
+                                 include_symbols, include_inlines, append,
+                                 sc_list);
+      } else if (target && !namespace_decl) {
+        const bool include_symbols = true;
+
+        // TODO Fix FindFunctions so that it doesn't return
+        //   instance methods for eFunctionNameTypeBase.
+
+        target->GetImages().FindFunctions(name, eFunctionNameTypeFull,
+                                          include_symbols, include_inlines,
+                                          append, sc_list);
+      }
+
+      // If we found more than one function, see if we can use the
+      // frame's decl context to remove functions that are shadowed
+      // by other functions which match in type but are nearer in scope.
+      //
+      // AddOneFunction will not add a function whose type has already been
+      // added, so if there's another function in the list with a matching
+      // type, check to see if their decl context is a parent of the current
+      // frame's or was imported via a and using statement, and pick the
+      // best match according to lookup rules.
+      if (sc_list.GetSize() > 1) {
+        // Collect some info about our frame's context.
+        StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
+        SymbolContext frame_sym_ctx;
+        if (frame != nullptr)
+          frame_sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
+                                                  lldb::eSymbolContextBlock);
+        CompilerDeclContext frame_decl_context =
+            frame_sym_ctx.block != nullptr
+                ? frame_sym_ctx.block->GetDeclContext()
+                : CompilerDeclContext();
+
+        // We can't do this without a compiler decl context for our frame.
+        if (frame_decl_context) {
+          clang::DeclContext *frame_decl_ctx =
+              (clang::DeclContext *)frame_decl_context.GetOpaqueDeclContext();
+          ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(
+              frame_decl_context.GetTypeSystem());
+
+          // Structure to hold the info needed when comparing function
+          // declarations.
+          struct FuncDeclInfo {
+            ConstString m_name;
+            CompilerType m_copied_type;
+            uint32_t m_decl_lvl;
+            SymbolContext m_sym_ctx;
+          };
+
+          // First, symplify things by looping through the symbol contexts
+          // to remove unwanted functions and separate out the functions we
+          // want to compare and prune into a separate list.
+          // Cache the info needed about the function declarations in a
+          // vector for efficiency.
+          SymbolContextList sc_sym_list;
+          uint32_t num_indices = sc_list.GetSize();
+          std::vector<FuncDeclInfo> fdi_cache;
+          fdi_cache.reserve(num_indices);
+          for (uint32_t index = 0; index < num_indices; ++index) {
+            FuncDeclInfo fdi;
+            SymbolContext sym_ctx;
+            sc_list.GetContextAtIndex(index, sym_ctx);
+
+            // We don't know enough about symbols to compare them,
+            // but we should keep them in the list.
+            Function *function = sym_ctx.function;
+            if (!function) {
+              sc_sym_list.Append(sym_ctx);
+              continue;
             }
-        }
-        
-        std::vector<clang::NamedDecl *> decls_from_modules;
-        
-        if (target)
-        {
-            if (ClangModulesDeclVendor *decl_vendor = target->GetClangModulesDeclVendor())
-            {
-                decl_vendor->FindDecls(name, false, UINT32_MAX, decls_from_modules);
+            // Filter out functions without declaration contexts, as well as
+            // class/instance methods, since they'll be skipped in the
+            // code that follows anyway.
+            CompilerDeclContext func_decl_context = function->GetDeclContext();
+            if (!func_decl_context ||
+                func_decl_context.IsClassMethod(nullptr, nullptr, nullptr))
+              continue;
+            // We can only prune functions for which we can copy the type.
+            CompilerType func_clang_type =
+                function->GetType()->GetFullCompilerType();
+            CompilerType copied_func_type = GuardedCopyType(func_clang_type);
+            if (!copied_func_type) {
+              sc_sym_list.Append(sym_ctx);
+              continue;
             }
-        }
 
-        if (!context.m_found.variable)
-        {
-            const bool include_inlines = false;
-            const bool append = false;
-
-            if (namespace_decl && module_sp)
-            {
-                const bool include_symbols = false;
-
-                module_sp->FindFunctions(name,
-                                         &namespace_decl,
-                                         eFunctionNameTypeBase,
-                                         include_symbols,
-                                         include_inlines,
-                                         append,
-                                         sc_list);
+            fdi.m_sym_ctx = sym_ctx;
+            fdi.m_name = function->GetName();
+            fdi.m_copied_type = copied_func_type;
+            fdi.m_decl_lvl = LLDB_INVALID_DECL_LEVEL;
+            if (fdi.m_copied_type && func_decl_context) {
+              // Call CountDeclLevels to get the number of parent scopes we
+              // have to look through before we find the function declaration.
+              // When comparing functions of the same type, the one with a
+              // lower count will be closer to us in the lookup scope and
+              // shadows the other.
+              clang::DeclContext *func_decl_ctx =
+                  (clang::DeclContext *)
+                      func_decl_context.GetOpaqueDeclContext();
+              fdi.m_decl_lvl =
+                  ast->CountDeclLevels(frame_decl_ctx, func_decl_ctx,
+                                       &fdi.m_name, &fdi.m_copied_type);
             }
-            else if (target && !namespace_decl)
-            {
-                const bool include_symbols = true;
-
-                // TODO Fix FindFunctions so that it doesn't return
-                //   instance methods for eFunctionNameTypeBase.
-
-                target->GetImages().FindFunctions(name,
-                                                  eFunctionNameTypeFull,
-                                                  include_symbols,
-                                                  include_inlines,
-                                                  append,
-                                                  sc_list);
+            fdi_cache.emplace_back(fdi);
+          }
+
+          // Loop through the functions in our cache looking for matching types,
+          // then compare their scope levels to see which is closer.
+          std::multimap<CompilerType, const FuncDeclInfo *> matches;
+          for (const FuncDeclInfo &fdi : fdi_cache) {
+            const CompilerType t = fdi.m_copied_type;
+            auto q = matches.find(t);
+            if (q != matches.end()) {
+              if (q->second->m_decl_lvl > fdi.m_decl_lvl)
+                // This function is closer; remove the old set.
+                matches.erase(t);
+              else if (q->second->m_decl_lvl < fdi.m_decl_lvl)
+                // The functions in our set are closer - skip this one.
+                continue;
             }
+            matches.insert(std::make_pair(t, &fdi));
+          }
 
-            // If we found more than one function, see if we can use the
-            // frame's decl context to remove functions that are shadowed
-            // by other functions which match in type but are nearer in scope.
-            //
-            // AddOneFunction will not add a function whose type has already been
-            // added, so if there's another function in the list with a matching
-            // type, check to see if their decl context is a parent of the current
-            // frame's or was imported via a and using statement, and pick the
-            // best match according to lookup rules.
-            if (sc_list.GetSize() > 1)
-            {
-                // Collect some info about our frame's context.
-                StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
-                SymbolContext frame_sym_ctx;
-                if (frame != nullptr)
-                    frame_sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction|lldb::eSymbolContextBlock);
-                CompilerDeclContext frame_decl_context = frame_sym_ctx.block != nullptr ? frame_sym_ctx.block->GetDeclContext() : CompilerDeclContext();
-
-                // We can't do this without a compiler decl context for our frame.
-                if (frame_decl_context)
-                {
-                    clang::DeclContext *frame_decl_ctx = (clang::DeclContext *)frame_decl_context.GetOpaqueDeclContext();
-                    ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(frame_decl_context.GetTypeSystem());
-
-                    // Structure to hold the info needed when comparing function
-                    // declarations.
-                    struct FuncDeclInfo
-                    {
-                        ConstString m_name;
-                        CompilerType m_copied_type;
-                        uint32_t m_decl_lvl;
-                        SymbolContext m_sym_ctx;
-                    };
-
-                    // First, symplify things by looping through the symbol contexts
-                    // to remove unwanted functions and separate out the functions we
-                    // want to compare and prune into a separate list.
-                    // Cache the info needed about the function declarations in a
-                    // vector for efficiency.
-                    SymbolContextList sc_sym_list;
-                    uint32_t num_indices = sc_list.GetSize();
-                    std::vector<FuncDeclInfo> fdi_cache;
-                    fdi_cache.reserve(num_indices);
-                    for (uint32_t index = 0; index < num_indices; ++index)
-                    {
-                        FuncDeclInfo fdi;
-                        SymbolContext sym_ctx;
-                        sc_list.GetContextAtIndex(index, sym_ctx);
-
-                        // We don't know enough about symbols to compare them,
-                        // but we should keep them in the list.
-                        Function *function = sym_ctx.function;
-                        if (!function)
-                        {
-                            sc_sym_list.Append(sym_ctx);
-                            continue;
-                        }
-                        // Filter out functions without declaration contexts, as well as
-                        // class/instance methods, since they'll be skipped in the
-                        // code that follows anyway.
-                        CompilerDeclContext func_decl_context = function->GetDeclContext();
-                        if (!func_decl_context || func_decl_context.IsClassMethod(nullptr, nullptr, nullptr))
-                            continue;
-                        // We can only prune functions for which we can copy the type.
-                        CompilerType func_clang_type = function->GetType()->GetFullCompilerType();
-                        CompilerType copied_func_type = GuardedCopyType(func_clang_type);
-                        if (!copied_func_type)
-                        {
-                            sc_sym_list.Append(sym_ctx);
-                            continue;
-                        }
-
-                        fdi.m_sym_ctx = sym_ctx;
-                        fdi.m_name = function->GetName();
-                        fdi.m_copied_type = copied_func_type;
-                        fdi.m_decl_lvl = LLDB_INVALID_DECL_LEVEL;
-                        if (fdi.m_copied_type && func_decl_context)
-                        {
-                            // Call CountDeclLevels to get the number of parent scopes we
-                            // have to look through before we find the function declaration.
-                            // When comparing functions of the same type, the one with a
-                            // lower count will be closer to us in the lookup scope and
-                            // shadows the other.
-                            clang::DeclContext *func_decl_ctx = (clang::DeclContext *)func_decl_context.GetOpaqueDeclContext();
-                            fdi.m_decl_lvl = ast->CountDeclLevels(frame_decl_ctx,
-                                                                  func_decl_ctx,
-                                                                  &fdi.m_name,
-                                                                  &fdi.m_copied_type);
-                        }
-                        fdi_cache.emplace_back(fdi);
-                    }
-
-                    // Loop through the functions in our cache looking for matching types,
-                    // then compare their scope levels to see which is closer.
-                    std::multimap<CompilerType, const FuncDeclInfo*> matches;
-                    for (const FuncDeclInfo &fdi : fdi_cache)
-                    {
-                        const CompilerType t = fdi.m_copied_type;
-                        auto q = matches.find(t);
-                        if (q != matches.end())
-                        {
-                            if (q->second->m_decl_lvl > fdi.m_decl_lvl)
-                                // This function is closer; remove the old set.
-                                matches.erase(t);
-                            else if (q->second->m_decl_lvl < fdi.m_decl_lvl)
-                                // The functions in our set are closer - skip this one.
-                                continue;
-                        }
-                        matches.insert(std::make_pair(t, &fdi));
-                    }
-
-                    // Loop through our matches and add their symbol contexts to our list.
-                    SymbolContextList sc_func_list;
-                    for (const auto &q : matches)
-                        sc_func_list.Append(q.second->m_sym_ctx);
-
-                    // Rejoin the lists with the functions in front.
-                    sc_list = sc_func_list;
-                    sc_list.Append(sc_sym_list);
-                }
-            }
+          // Loop through our matches and add their symbol contexts to our list.
+          SymbolContextList sc_func_list;
+          for (const auto &q : matches)
+            sc_func_list.Append(q.second->m_sym_ctx);
 
-            if (sc_list.GetSize())
-            {
-                Symbol *extern_symbol = NULL;
-                Symbol *non_extern_symbol = NULL;
-
-                for (uint32_t index = 0, num_indices = sc_list.GetSize();
-                     index < num_indices;
-                     ++index)
-                {
-                    SymbolContext sym_ctx;
-                    sc_list.GetContextAtIndex(index, sym_ctx);
-
-                    if (sym_ctx.function)
-                    {
-                        CompilerDeclContext decl_ctx = sym_ctx.function->GetDeclContext();
-
-                        if (!decl_ctx)
-                            continue;
-
-                        // Filter out class/instance methods.
-                        if (decl_ctx.IsClassMethod(nullptr, nullptr, nullptr))
-                            continue;
-
-                        AddOneFunction(context, sym_ctx.function, NULL, current_id);
-                        context.m_found.function_with_type_info = true;
-                        context.m_found.function = true;
-                    }
-                    else if (sym_ctx.symbol)
-                    {
-                        if (sym_ctx.symbol->GetType() == eSymbolTypeReExported && target)
-                        {
-                            sym_ctx.symbol = sym_ctx.symbol->ResolveReExportedSymbol(*target);
-                            if (sym_ctx.symbol == NULL)
-                                continue;
-                        }
-
-                        if (sym_ctx.symbol->IsExternal())
-                            extern_symbol = sym_ctx.symbol;
-                        else
-                            non_extern_symbol = sym_ctx.symbol;
-                    }
-                }
-                
-                if (!context.m_found.function_with_type_info)
-                {
-                    for (clang::NamedDecl *decl : decls_from_modules)
-                    {
-                        if (llvm::isa<clang::FunctionDecl>(decl))
-                        {
-                            clang::NamedDecl *copied_decl = llvm::cast_or_null<FunctionDecl>(m_ast_importer_sp->CopyDecl(m_ast_context, &decl->getASTContext(), decl));
-                            if (copied_decl)
-                            {
-                                context.AddNamedDecl(copied_decl);
-                                context.m_found.function_with_type_info = true;
-                            }
-                        }
-                    }
-                }
-
-                if (!context.m_found.function_with_type_info)
-                {
-                    if (extern_symbol)
-                    {
-                        AddOneFunction (context, NULL, extern_symbol, current_id);
-                        context.m_found.function = true;
-                    }
-                    else if (non_extern_symbol)
-                    {
-                        AddOneFunction (context, NULL, non_extern_symbol, current_id);
-                        context.m_found.function = true;
-                    }
-                }
+          // Rejoin the lists with the functions in front.
+          sc_list = sc_func_list;
+          sc_list.Append(sc_sym_list);
+        }
+      }
+
+      if (sc_list.GetSize()) {
+        Symbol *extern_symbol = NULL;
+        Symbol *non_extern_symbol = NULL;
+
+        for (uint32_t index = 0, num_indices = sc_list.GetSize();
+             index < num_indices; ++index) {
+          SymbolContext sym_ctx;
+          sc_list.GetContextAtIndex(index, sym_ctx);
+
+          if (sym_ctx.function) {
+            CompilerDeclContext decl_ctx = sym_ctx.function->GetDeclContext();
+
+            if (!decl_ctx)
+              continue;
+
+            // Filter out class/instance methods.
+            if (decl_ctx.IsClassMethod(nullptr, nullptr, nullptr))
+              continue;
+
+            AddOneFunction(context, sym_ctx.function, NULL, current_id);
+            context.m_found.function_with_type_info = true;
+            context.m_found.function = true;
+          } else if (sym_ctx.symbol) {
+            if (sym_ctx.symbol->GetType() == eSymbolTypeReExported && target) {
+              sym_ctx.symbol = sym_ctx.symbol->ResolveReExportedSymbol(*target);
+              if (sym_ctx.symbol == NULL)
+                continue;
             }
-            
-            if (!context.m_found.function_with_type_info)
-            {
-                // Try the modules next.
-                
-                do
-                {
-                    if (ClangModulesDeclVendor *modules_decl_vendor = m_target->GetClangModulesDeclVendor())
-                    {
-                        bool append = false;
-                        uint32_t max_matches = 1;
-                        std::vector <clang::NamedDecl *> decls;
-                        
-                        if (!modules_decl_vendor->FindDecls(name,
-                                                            append,
-                                                            max_matches,
-                                                            decls))
-                            break;
-                        
-                        clang::NamedDecl *const decl_from_modules = decls[0];
-                        
-                        if (llvm::isa<clang::FunctionDecl>(decl_from_modules))
-                        {
-                            if (log)
-                            {
-                                log->Printf("  CAS::FEVD[%u] Matching function found for \"%s\" in the modules",
-                                            current_id,
-                                            name.GetCString());
-                            }
-                            
-                            clang::Decl *copied_decl = m_ast_importer_sp->CopyDecl(m_ast_context, &decl_from_modules->getASTContext(), decl_from_modules);
-                            clang::FunctionDecl *copied_function_decl = copied_decl ? dyn_cast<clang::FunctionDecl>(copied_decl) : nullptr;
-                            
-                            if (!copied_function_decl)
-                            {
-                                if (log)
-                                    log->Printf("  CAS::FEVD[%u] - Couldn't export a function declaration from the modules",
-                                                current_id);
-                                
-                                break;
-                            }
-                            
-                            MaybeRegisterFunctionBody(copied_function_decl);
-                            
-                            context.AddNamedDecl(copied_function_decl);
-                            
-                            context.m_found.function_with_type_info = true;
-                            context.m_found.function = true;
-                        }
-                        else if (llvm::isa<clang::VarDecl>(decl_from_modules))
-                        {
-                            if (log)
-                            {
-                                log->Printf("  CAS::FEVD[%u] Matching variable found for \"%s\" in the modules",
-                                            current_id,
-                                            name.GetCString());
-                            }
-                            
-                            clang::Decl *copied_decl = m_ast_importer_sp->CopyDecl(m_ast_context, &decl_from_modules->getASTContext(), decl_from_modules);
-                            clang::VarDecl *copied_var_decl = copied_decl ? dyn_cast_or_null<clang::VarDecl>(copied_decl) : nullptr;
-                            
-                            if (!copied_var_decl)
-                            {
-                                if (log)
-                                    log->Printf("  CAS::FEVD[%u] - Couldn't export a variable declaration from the modules",
-                                                current_id);
-                                
-                                break;
-                            }
-                            
-                            context.AddNamedDecl(copied_var_decl);
-                            
-                            context.m_found.variable = true;
-                        }
-                    }
-                } while (0);
+
+            if (sym_ctx.symbol->IsExternal())
+              extern_symbol = sym_ctx.symbol;
+            else
+              non_extern_symbol = sym_ctx.symbol;
+          }
+        }
+
+        if (!context.m_found.function_with_type_info) {
+          for (clang::NamedDecl *decl : decls_from_modules) {
+            if (llvm::isa<clang::FunctionDecl>(decl)) {
+              clang::NamedDecl *copied_decl =
+                  llvm::cast_or_null<FunctionDecl>(m_ast_importer_sp->CopyDecl(
+                      m_ast_context, &decl->getASTContext(), decl));
+              if (copied_decl) {
+                context.AddNamedDecl(copied_decl);
+                context.m_found.function_with_type_info = true;
+              }
             }
+          }
+        }
 
-            if (target && !context.m_found.variable && !namespace_decl)
-            {
-                // We couldn't find a non-symbol variable for this.  Now we'll hunt for a generic
-                // data symbol, and -- if it is found -- treat it as a variable.
-
-                const Symbol *data_symbol = FindGlobalDataSymbol(*target, name);
-
-                if (data_symbol)
-                {
-                    std::string warning("got name from symbols: ");
-                    warning.append(name.AsCString());
-                    const unsigned diag_id = m_ast_context->getDiagnostics().getCustomDiagID(clang::DiagnosticsEngine::Level::Warning, "%0");
-                    m_ast_context->getDiagnostics().Report(diag_id) << warning.c_str();
-                    AddOneGenericVariable(context, *data_symbol, current_id);
-                    context.m_found.variable = true;
-                }
+        if (!context.m_found.function_with_type_info) {
+          if (extern_symbol) {
+            AddOneFunction(context, NULL, extern_symbol, current_id);
+            context.m_found.function = true;
+          } else if (non_extern_symbol) {
+            AddOneFunction(context, NULL, non_extern_symbol, current_id);
+            context.m_found.function = true;
+          }
+        }
+      }
+
+      if (!context.m_found.function_with_type_info) {
+        // Try the modules next.
+
+        do {
+          if (ClangModulesDeclVendor *modules_decl_vendor =
+                  m_target->GetClangModulesDeclVendor()) {
+            bool append = false;
+            uint32_t max_matches = 1;
+            std::vector<clang::NamedDecl *> decls;
+
+            if (!modules_decl_vendor->FindDecls(name, append, max_matches,
+                                                decls))
+              break;
+
+            clang::NamedDecl *const decl_from_modules = decls[0];
+
+            if (llvm::isa<clang::FunctionDecl>(decl_from_modules)) {
+              if (log) {
+                log->Printf("  CAS::FEVD[%u] Matching function found for "
+                            "\"%s\" in the modules",
+                            current_id, name.GetCString());
+              }
+
+              clang::Decl *copied_decl = m_ast_importer_sp->CopyDecl(
+                  m_ast_context, &decl_from_modules->getASTContext(),
+                  decl_from_modules);
+              clang::FunctionDecl *copied_function_decl =
+                  copied_decl ? dyn_cast<clang::FunctionDecl>(copied_decl)
+                              : nullptr;
+
+              if (!copied_function_decl) {
+                if (log)
+                  log->Printf("  CAS::FEVD[%u] - Couldn't export a function "
+                              "declaration from the modules",
+                              current_id);
+
+                break;
+              }
+
+              MaybeRegisterFunctionBody(copied_function_decl);
+
+              context.AddNamedDecl(copied_function_decl);
+
+              context.m_found.function_with_type_info = true;
+              context.m_found.function = true;
+            } else if (llvm::isa<clang::VarDecl>(decl_from_modules)) {
+              if (log) {
+                log->Printf("  CAS::FEVD[%u] Matching variable found for "
+                            "\"%s\" in the modules",
+                            current_id, name.GetCString());
+              }
+
+              clang::Decl *copied_decl = m_ast_importer_sp->CopyDecl(
+                  m_ast_context, &decl_from_modules->getASTContext(),
+                  decl_from_modules);
+              clang::VarDecl *copied_var_decl =
+                  copied_decl ? dyn_cast_or_null<clang::VarDecl>(copied_decl)
+                              : nullptr;
+
+              if (!copied_var_decl) {
+                if (log)
+                  log->Printf("  CAS::FEVD[%u] - Couldn't export a variable "
+                              "declaration from the modules",
+                              current_id);
+
+                break;
+              }
+
+              context.AddNamedDecl(copied_var_decl);
+
+              context.m_found.variable = true;
             }
+          }
+        } while (0);
+      }
+
+      if (target && !context.m_found.variable && !namespace_decl) {
+        // We couldn't find a non-symbol variable for this.  Now we'll hunt for
+        // a generic
+        // data symbol, and -- if it is found -- treat it as a variable.
+
+        const Symbol *data_symbol = FindGlobalDataSymbol(*target, name);
+
+        if (data_symbol) {
+          std::string warning("got name from symbols: ");
+          warning.append(name.AsCString());
+          const unsigned diag_id =
+              m_ast_context->getDiagnostics().getCustomDiagID(
+                  clang::DiagnosticsEngine::Level::Warning, "%0");
+          m_ast_context->getDiagnostics().Report(diag_id) << warning.c_str();
+          AddOneGenericVariable(context, *data_symbol, current_id);
+          context.m_found.variable = true;
         }
+      }
     }
+  }
 }
 
-//static opaque_compiler_type_t
-//MaybePromoteToBlockPointerType
+// static opaque_compiler_type_t
+// MaybePromoteToBlockPointerType
 //(
 //    ASTContext *ast_context,
 //    opaque_compiler_type_t candidate_type
@@ -1647,14 +1562,16 @@ ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context,
 //
 //    QualType candidate_qual_type = QualType::getFromOpaquePtr(candidate_type);
 //
-//    const PointerType *candidate_pointer_type = dyn_cast<PointerType>(candidate_qual_type);
+//    const PointerType *candidate_pointer_type =
+//    dyn_cast<PointerType>(candidate_qual_type);
 //
 //    if (!candidate_pointer_type)
 //        return candidate_type;
 //
 //    QualType pointee_qual_type = candidate_pointer_type->getPointeeType();
 //
-//    const RecordType *pointee_record_type = dyn_cast<RecordType>(pointee_qual_type);
+//    const RecordType *pointee_record_type =
+//    dyn_cast<RecordType>(pointee_qual_type);
 //
 //    if (!pointee_record_type)
 //        return candidate_type;
@@ -1664,659 +1581,639 @@ ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context,
 //    if (!pointee_record_decl->isRecord())
 //        return candidate_type;
 //
-//    if (!pointee_record_decl->getName().startswith(llvm::StringRef("__block_literal_")))
+//    if
+//    (!pointee_record_decl->getName().startswith(llvm::StringRef("__block_literal_")))
 //        return candidate_type;
 //
-//    QualType generic_function_type = ast_context->getFunctionNoProtoType(ast_context->UnknownAnyTy);
-//    QualType block_pointer_type = ast_context->getBlockPointerType(generic_function_type);
+//    QualType generic_function_type =
+//    ast_context->getFunctionNoProtoType(ast_context->UnknownAnyTy);
+//    QualType block_pointer_type =
+//    ast_context->getBlockPointerType(generic_function_type);
 //
 //    return block_pointer_type.getAsOpaquePtr();
 //}
 
-bool
-ClangExpressionDeclMap::GetVariableValue (VariableSP &var,
-                                          lldb_private::Value &var_location,
-                                          TypeFromUser *user_type,
-                                          TypeFromParser *parser_type)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-
-    Type *var_type = var->GetType();
-
-    if (!var_type)
-    {
-        if (log)
-            log->PutCString("Skipped a definition because it has no type");
-        return false;
-    }
-
-    CompilerType var_clang_type = var_type->GetFullCompilerType ();
+bool ClangExpressionDeclMap::GetVariableValue(VariableSP &var,
+                                              lldb_private::Value &var_location,
+                                              TypeFromUser *user_type,
+                                              TypeFromParser *parser_type) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    if (!var_clang_type)
-    {
-        if (log)
-            log->PutCString("Skipped a definition because it has no Clang type");
-        return false;
-    }
-
-    ClangASTContext *clang_ast = llvm::dyn_cast_or_null<ClangASTContext>(var_type->GetForwardCompilerType().GetTypeSystem());
-
-    if (!clang_ast)
-    {
-        if (log)
-            log->PutCString("Skipped a definition because it has no Clang AST");
-        return false;
-    }
+  Type *var_type = var->GetType();
 
+  if (!var_type) {
+    if (log)
+      log->PutCString("Skipped a definition because it has no type");
+    return false;
+  }
 
-    ASTContext *ast = clang_ast->getASTContext();
+  CompilerType var_clang_type = var_type->GetFullCompilerType();
 
-    if (!ast)
-    {
-        if (log)
-            log->PutCString("There is no AST context for the current execution context");
-        return false;
-    }
-    //var_clang_type = MaybePromoteToBlockPointerType (ast, var_clang_type);
+  if (!var_clang_type) {
+    if (log)
+      log->PutCString("Skipped a definition because it has no Clang type");
+    return false;
+  }
 
-    DWARFExpression &var_location_expr = var->LocationExpression();
+  ClangASTContext *clang_ast = llvm::dyn_cast_or_null<ClangASTContext>(
+      var_type->GetForwardCompilerType().GetTypeSystem());
 
-    Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
-    Error err;
+  if (!clang_ast) {
+    if (log)
+      log->PutCString("Skipped a definition because it has no Clang AST");
+    return false;
+  }
 
-    if (var->GetLocationIsConstantValueData())
-    {
-        DataExtractor const_value_extractor;
+  ASTContext *ast = clang_ast->getASTContext();
 
-        if (var_location_expr.GetExpressionData(const_value_extractor))
-        {
-            var_location = Value(const_value_extractor.GetDataStart(), const_value_extractor.GetByteSize());
-            var_location.SetValueType(Value::eValueTypeHostAddress);
-        }
-        else
-        {
-            if (log)
-                log->Printf("Error evaluating constant variable: %s", err.AsCString());
-            return false;
-        }
+  if (!ast) {
+    if (log)
+      log->PutCString(
+          "There is no AST context for the current execution context");
+    return false;
+  }
+  // var_clang_type = MaybePromoteToBlockPointerType (ast, var_clang_type);
+
+  DWARFExpression &var_location_expr = var->LocationExpression();
+
+  Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
+  Error err;
+
+  if (var->GetLocationIsConstantValueData()) {
+    DataExtractor const_value_extractor;
+
+    if (var_location_expr.GetExpressionData(const_value_extractor)) {
+      var_location = Value(const_value_extractor.GetDataStart(),
+                           const_value_extractor.GetByteSize());
+      var_location.SetValueType(Value::eValueTypeHostAddress);
+    } else {
+      if (log)
+        log->Printf("Error evaluating constant variable: %s", err.AsCString());
+      return false;
     }
+  }
 
-    CompilerType type_to_use = GuardedCopyType(var_clang_type);
+  CompilerType type_to_use = GuardedCopyType(var_clang_type);
 
-    if (!type_to_use)
-    {
-        if (log)
-            log->Printf("Couldn't copy a variable's type into the parser's AST context");
+  if (!type_to_use) {
+    if (log)
+      log->Printf(
+          "Couldn't copy a variable's type into the parser's AST context");
 
-        return false;
-    }
+    return false;
+  }
 
-    if (parser_type)
-        *parser_type = TypeFromParser(type_to_use);
+  if (parser_type)
+    *parser_type = TypeFromParser(type_to_use);
 
-    if (var_location.GetContextType() == Value::eContextTypeInvalid)
-        var_location.SetCompilerType(type_to_use);
+  if (var_location.GetContextType() == Value::eContextTypeInvalid)
+    var_location.SetCompilerType(type_to_use);
 
-    if (var_location.GetValueType() == Value::eValueTypeFileAddress)
-    {
-        SymbolContext var_sc;
-        var->CalculateSymbolContext(&var_sc);
+  if (var_location.GetValueType() == Value::eValueTypeFileAddress) {
+    SymbolContext var_sc;
+    var->CalculateSymbolContext(&var_sc);
 
-        if (!var_sc.module_sp)
-            return false;
+    if (!var_sc.module_sp)
+      return false;
 
-        Address so_addr(var_location.GetScalar().ULongLong(), var_sc.module_sp->GetSectionList());
+    Address so_addr(var_location.GetScalar().ULongLong(),
+                    var_sc.module_sp->GetSectionList());
 
-        lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
+    lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
 
-        if (load_addr != LLDB_INVALID_ADDRESS)
-        {
-            var_location.GetScalar() = load_addr;
-            var_location.SetValueType(Value::eValueTypeLoadAddress);
-        }
+    if (load_addr != LLDB_INVALID_ADDRESS) {
+      var_location.GetScalar() = load_addr;
+      var_location.SetValueType(Value::eValueTypeLoadAddress);
     }
+  }
 
-    if (user_type)
-        *user_type = TypeFromUser(var_clang_type);
+  if (user_type)
+    *user_type = TypeFromUser(var_clang_type);
 
-    return true;
+  return true;
 }
 
-void
-ClangExpressionDeclMap::AddOneVariable (NameSearchContext &context, VariableSP var, ValueObjectSP valobj, unsigned int current_id)
-{
-    assert (m_parser_vars.get());
-
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
+                                            VariableSP var,
+                                            ValueObjectSP valobj,
+                                            unsigned int current_id) {
+  assert(m_parser_vars.get());
 
-    TypeFromUser ut;
-    TypeFromParser pt;
-    Value var_location;
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    if (!GetVariableValue (var, var_location, &ut, &pt))
-        return;
-
-    clang::QualType parser_opaque_type = QualType::getFromOpaquePtr(pt.GetOpaqueQualType());
-
-    if (parser_opaque_type.isNull())
-        return;
-
-    if (const clang::Type *parser_type = parser_opaque_type.getTypePtr())
-    {
-        if (const TagType *tag_type = dyn_cast<TagType>(parser_type))
-            CompleteType(tag_type->getDecl());
-        if (const ObjCObjectPointerType *objc_object_ptr_type = dyn_cast<ObjCObjectPointerType>(parser_type))
-            CompleteType(objc_object_ptr_type->getInterfaceDecl());
-    }
+  TypeFromUser ut;
+  TypeFromParser pt;
+  Value var_location;
 
+  if (!GetVariableValue(var, var_location, &ut, &pt))
+    return;
 
-    bool is_reference = pt.IsReferenceType();
-
-    NamedDecl *var_decl = NULL;
-    if (is_reference)
-        var_decl = context.AddVarDecl(pt);
-    else
-        var_decl = context.AddVarDecl(pt.GetLValueReferenceType());
-
-    std::string decl_name(context.m_decl_name.getAsString());
-    ConstString entity_name(decl_name.c_str());
-    ClangExpressionVariable *entity(new ClangExpressionVariable(valobj));
-    m_found_entities.AddNewlyConstructedVariable(entity);
-
-    assert (entity);
-    entity->EnableParserVars(GetParserID());
-    ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
-    parser_vars->m_parser_type = pt;
-    parser_vars->m_named_decl  = var_decl;
-    parser_vars->m_llvm_value  = NULL;
-    parser_vars->m_lldb_value  = var_location;
-    parser_vars->m_lldb_var    = var;
+  clang::QualType parser_opaque_type =
+      QualType::getFromOpaquePtr(pt.GetOpaqueQualType());
 
-    if (is_reference)
-        entity->m_flags |= ClangExpressionVariable::EVTypeIsReference;
+  if (parser_opaque_type.isNull())
+    return;
 
-    if (log)
-    {
-        ASTDumper orig_dumper(ut.GetOpaqueQualType());
-        ASTDumper ast_dumper(var_decl);
-        log->Printf("  CEDM::FEVD[%u] Found variable %s, returned %s (original %s)", current_id, decl_name.c_str(), ast_dumper.GetCString(), orig_dumper.GetCString());
-    }
+  if (const clang::Type *parser_type = parser_opaque_type.getTypePtr()) {
+    if (const TagType *tag_type = dyn_cast<TagType>(parser_type))
+      CompleteType(tag_type->getDecl());
+    if (const ObjCObjectPointerType *objc_object_ptr_type =
+            dyn_cast<ObjCObjectPointerType>(parser_type))
+      CompleteType(objc_object_ptr_type->getInterfaceDecl());
+  }
+
+  bool is_reference = pt.IsReferenceType();
+
+  NamedDecl *var_decl = NULL;
+  if (is_reference)
+    var_decl = context.AddVarDecl(pt);
+  else
+    var_decl = context.AddVarDecl(pt.GetLValueReferenceType());
+
+  std::string decl_name(context.m_decl_name.getAsString());
+  ConstString entity_name(decl_name.c_str());
+  ClangExpressionVariable *entity(new ClangExpressionVariable(valobj));
+  m_found_entities.AddNewlyConstructedVariable(entity);
+
+  assert(entity);
+  entity->EnableParserVars(GetParserID());
+  ClangExpressionVariable::ParserVars *parser_vars =
+      entity->GetParserVars(GetParserID());
+  parser_vars->m_parser_type = pt;
+  parser_vars->m_named_decl = var_decl;
+  parser_vars->m_llvm_value = NULL;
+  parser_vars->m_lldb_value = var_location;
+  parser_vars->m_lldb_var = var;
+
+  if (is_reference)
+    entity->m_flags |= ClangExpressionVariable::EVTypeIsReference;
+
+  if (log) {
+    ASTDumper orig_dumper(ut.GetOpaqueQualType());
+    ASTDumper ast_dumper(var_decl);
+    log->Printf("  CEDM::FEVD[%u] Found variable %s, returned %s (original %s)",
+                current_id, decl_name.c_str(), ast_dumper.GetCString(),
+                orig_dumper.GetCString());
+  }
 }
 
-void
-ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
-                                       ExpressionVariableSP &pvar_sp,
-                                       unsigned int current_id)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-
-    TypeFromUser user_type (llvm::cast<ClangExpressionVariable>(pvar_sp.get())->GetTypeFromUser());
-
-    TypeFromParser parser_type (GuardedCopyType(user_type));
-
-    if (!parser_type.GetOpaqueQualType())
-    {
-        if (log)
-            log->Printf("  CEDM::FEVD[%u] Couldn't import type for pvar %s", current_id, pvar_sp->GetName().GetCString());
-        return;
-    }
+void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
+                                            ExpressionVariableSP &pvar_sp,
+                                            unsigned int current_id) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    NamedDecl *var_decl = context.AddVarDecl(parser_type.GetLValueReferenceType());
+  TypeFromUser user_type(
+      llvm::cast<ClangExpressionVariable>(pvar_sp.get())->GetTypeFromUser());
 
-    llvm::cast<ClangExpressionVariable>(pvar_sp.get())->EnableParserVars(GetParserID());
-    ClangExpressionVariable::ParserVars *parser_vars = llvm::cast<ClangExpressionVariable>(pvar_sp.get())->GetParserVars(GetParserID());
-    parser_vars->m_parser_type = parser_type;
-    parser_vars->m_named_decl = var_decl;
-    parser_vars->m_llvm_value = NULL;
-    parser_vars->m_lldb_value.Clear();
+  TypeFromParser parser_type(GuardedCopyType(user_type));
 
+  if (!parser_type.GetOpaqueQualType()) {
     if (log)
-    {
-        ASTDumper ast_dumper(var_decl);
-        log->Printf("  CEDM::FEVD[%u] Added pvar %s, returned %s", current_id, pvar_sp->GetName().GetCString(), ast_dumper.GetCString());
-    }
+      log->Printf("  CEDM::FEVD[%u] Couldn't import type for pvar %s",
+                  current_id, pvar_sp->GetName().GetCString());
+    return;
+  }
+
+  NamedDecl *var_decl =
+      context.AddVarDecl(parser_type.GetLValueReferenceType());
+
+  llvm::cast<ClangExpressionVariable>(pvar_sp.get())
+      ->EnableParserVars(GetParserID());
+  ClangExpressionVariable::ParserVars *parser_vars =
+      llvm::cast<ClangExpressionVariable>(pvar_sp.get())
+          ->GetParserVars(GetParserID());
+  parser_vars->m_parser_type = parser_type;
+  parser_vars->m_named_decl = var_decl;
+  parser_vars->m_llvm_value = NULL;
+  parser_vars->m_lldb_value.Clear();
+
+  if (log) {
+    ASTDumper ast_dumper(var_decl);
+    log->Printf("  CEDM::FEVD[%u] Added pvar %s, returned %s", current_id,
+                pvar_sp->GetName().GetCString(), ast_dumper.GetCString());
+  }
 }
 
-void
-ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
-                                              const Symbol &symbol,
-                                              unsigned int current_id)
-{
-    assert(m_parser_vars.get());
+void ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
+                                                   const Symbol &symbol,
+                                                   unsigned int current_id) {
+  assert(m_parser_vars.get());
 
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
+  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());
-    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,
-                                                                m_parser_vars->m_target_info.address_byte_size));
-    m_found_entities.AddNewlyConstructedVariable(entity);
-    
-    entity->EnableParserVars(GetParserID());
-    ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
-
-    const Address symbol_address = symbol.GetAddress();
-    lldb::addr_t symbol_load_addr = symbol_address.GetLoadAddress(target);
-
-    //parser_vars->m_lldb_value.SetContext(Value::eContextTypeClangType, user_type.GetOpaqueQualType());
-    parser_vars->m_lldb_value.SetCompilerType(user_type);
-    parser_vars->m_lldb_value.GetScalar() = symbol_load_addr;
-    parser_vars->m_lldb_value.SetValueType(Value::eValueTypeLoadAddress);
-
-    parser_vars->m_parser_type = parser_type;
-    parser_vars->m_named_decl  = var_decl;
-    parser_vars->m_llvm_value  = NULL;
-    parser_vars->m_lldb_sym    = &symbol;
-
-    if (log)
-    {
-        ASTDumper ast_dumper(var_decl);
+  if (target == NULL)
+    return;
 
-        log->Printf("  CEDM::FEVD[%u] Found variable %s, returned %s", current_id, decl_name.c_str(), ast_dumper.GetCString());
-    }
+  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());
+  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,
+      m_parser_vars->m_target_info.address_byte_size));
+  m_found_entities.AddNewlyConstructedVariable(entity);
+
+  entity->EnableParserVars(GetParserID());
+  ClangExpressionVariable::ParserVars *parser_vars =
+      entity->GetParserVars(GetParserID());
+
+  const Address symbol_address = symbol.GetAddress();
+  lldb::addr_t symbol_load_addr = symbol_address.GetLoadAddress(target);
+
+  // parser_vars->m_lldb_value.SetContext(Value::eContextTypeClangType,
+  // user_type.GetOpaqueQualType());
+  parser_vars->m_lldb_value.SetCompilerType(user_type);
+  parser_vars->m_lldb_value.GetScalar() = symbol_load_addr;
+  parser_vars->m_lldb_value.SetValueType(Value::eValueTypeLoadAddress);
+
+  parser_vars->m_parser_type = parser_type;
+  parser_vars->m_named_decl = var_decl;
+  parser_vars->m_llvm_value = NULL;
+  parser_vars->m_lldb_sym = &symbol;
+
+  if (log) {
+    ASTDumper ast_dumper(var_decl);
+
+    log->Printf("  CEDM::FEVD[%u] Found variable %s, returned %s", current_id,
+                decl_name.c_str(), ast_dumper.GetCString());
+  }
 }
 
-bool
-ClangExpressionDeclMap::ResolveUnknownTypes()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-    Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
+bool ClangExpressionDeclMap::ResolveUnknownTypes() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+  Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
 
-    ClangASTContext *scratch_ast_context = target->GetScratchClangASTContext();
+  ClangASTContext *scratch_ast_context = target->GetScratchClangASTContext();
 
-    for (size_t index = 0, num_entities = m_found_entities.GetSize();
-         index < num_entities;
-         ++index)
-    {
-        ExpressionVariableSP entity = m_found_entities.GetVariableAtIndex(index);
+  for (size_t index = 0, num_entities = m_found_entities.GetSize();
+       index < num_entities; ++index) {
+    ExpressionVariableSP entity = m_found_entities.GetVariableAtIndex(index);
 
-        ClangExpressionVariable::ParserVars *parser_vars = llvm::cast<ClangExpressionVariable>(entity.get())->GetParserVars(GetParserID());
+    ClangExpressionVariable::ParserVars *parser_vars =
+        llvm::cast<ClangExpressionVariable>(entity.get())
+            ->GetParserVars(GetParserID());
 
-        if (entity->m_flags & ClangExpressionVariable::EVUnknownType)
-        {
-            const NamedDecl *named_decl = parser_vars->m_named_decl;
-            const VarDecl *var_decl = dyn_cast<VarDecl>(named_decl);
+    if (entity->m_flags & ClangExpressionVariable::EVUnknownType) {
+      const NamedDecl *named_decl = parser_vars->m_named_decl;
+      const VarDecl *var_decl = dyn_cast<VarDecl>(named_decl);
 
-            if (!var_decl)
-            {
-                if (log)
-                    log->Printf("Entity of unknown type does not have a VarDecl");
-                return false;
-            }
+      if (!var_decl) {
+        if (log)
+          log->Printf("Entity of unknown type does not have a VarDecl");
+        return false;
+      }
 
-            if (log)
-            {
-                ASTDumper ast_dumper(const_cast<VarDecl*>(var_decl));
-                log->Printf("Variable of unknown type now has Decl %s", ast_dumper.GetCString());
-            }
+      if (log) {
+        ASTDumper ast_dumper(const_cast<VarDecl *>(var_decl));
+        log->Printf("Variable of unknown type now has Decl %s",
+                    ast_dumper.GetCString());
+      }
 
-            QualType var_type = var_decl->getType();
-            TypeFromParser parser_type(var_type.getAsOpaquePtr(), ClangASTContext::GetASTContext(&var_decl->getASTContext()));
+      QualType var_type = var_decl->getType();
+      TypeFromParser parser_type(
+          var_type.getAsOpaquePtr(),
+          ClangASTContext::GetASTContext(&var_decl->getASTContext()));
 
-            lldb::opaque_compiler_type_t copied_type = m_ast_importer_sp->CopyType(scratch_ast_context->getASTContext(), &var_decl->getASTContext(), var_type.getAsOpaquePtr());
+      lldb::opaque_compiler_type_t copied_type = m_ast_importer_sp->CopyType(
+          scratch_ast_context->getASTContext(), &var_decl->getASTContext(),
+          var_type.getAsOpaquePtr());
 
-            if (!copied_type)
-            {
-                if (log)
-                    log->Printf("ClangExpressionDeclMap::ResolveUnknownType - Couldn't import the type for a variable");
+      if (!copied_type) {
+        if (log)
+          log->Printf("ClangExpressionDeclMap::ResolveUnknownType - Couldn't "
+                      "import the type for a variable");
 
-                return (bool) lldb::ExpressionVariableSP();
-            }
+        return (bool)lldb::ExpressionVariableSP();
+      }
 
-            TypeFromUser user_type(copied_type, scratch_ast_context);
+      TypeFromUser user_type(copied_type, scratch_ast_context);
 
-//            parser_vars->m_lldb_value.SetContext(Value::eContextTypeClangType, user_type.GetOpaqueQualType());
-            parser_vars->m_lldb_value.SetCompilerType(user_type);
-            parser_vars->m_parser_type = parser_type;
+      //            parser_vars->m_lldb_value.SetContext(Value::eContextTypeClangType,
+      //            user_type.GetOpaqueQualType());
+      parser_vars->m_lldb_value.SetCompilerType(user_type);
+      parser_vars->m_parser_type = parser_type;
 
-            entity->SetCompilerType(user_type);
+      entity->SetCompilerType(user_type);
 
-            entity->m_flags &= ~(ClangExpressionVariable::EVUnknownType);
-        }
+      entity->m_flags &= ~(ClangExpressionVariable::EVUnknownType);
     }
+  }
 
-    return true;
+  return true;
 }
 
-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);
-
-    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;
-    }
-
-    TypeFromParser parser_clang_type (clang_type);
-
-    NamedDecl *var_decl = context.AddVarDecl(parser_clang_type);
-
-    ClangExpressionVariable *entity(new ClangExpressionVariable(m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
-                                                                m_parser_vars->m_target_info.byte_order,
-                                                                m_parser_vars->m_target_info.address_byte_size));
-    m_found_entities.AddNewlyConstructedVariable(entity);
+void ClangExpressionDeclMap::AddOneRegister(NameSearchContext &context,
+                                            const RegisterInfo *reg_info,
+                                            unsigned int current_id) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    std::string decl_name(context.m_decl_name.getAsString());
-    entity->SetName (ConstString (decl_name.c_str()));
-    entity->SetRegisterInfo (reg_info);
-    entity->EnableParserVars(GetParserID());
-    ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
-    parser_vars->m_parser_type = parser_clang_type;
-    parser_vars->m_named_decl = var_decl;
-    parser_vars->m_llvm_value = NULL;
-    parser_vars->m_lldb_value.Clear();
-    entity->m_flags |= ClangExpressionVariable::EVBareRegister;
+  CompilerType clang_type =
+      ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(
+          m_ast_context, reg_info->encoding, reg_info->byte_size * 8);
 
+  if (!clang_type) {
     if (log)
-    {
-        ASTDumper ast_dumper(var_decl);
-        log->Printf("  CEDM::FEVD[%d] Added register %s, returned %s", current_id, context.m_decl_name.getAsString().c_str(), ast_dumper.GetCString());
-    }
+      log->Printf("  Tried to add a type for %s, but couldn't get one",
+                  context.m_decl_name.getAsString().c_str());
+    return;
+  }
+
+  TypeFromParser parser_clang_type(clang_type);
+
+  NamedDecl *var_decl = context.AddVarDecl(parser_clang_type);
+
+  ClangExpressionVariable *entity(new ClangExpressionVariable(
+      m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
+      m_parser_vars->m_target_info.byte_order,
+      m_parser_vars->m_target_info.address_byte_size));
+  m_found_entities.AddNewlyConstructedVariable(entity);
+
+  std::string decl_name(context.m_decl_name.getAsString());
+  entity->SetName(ConstString(decl_name.c_str()));
+  entity->SetRegisterInfo(reg_info);
+  entity->EnableParserVars(GetParserID());
+  ClangExpressionVariable::ParserVars *parser_vars =
+      entity->GetParserVars(GetParserID());
+  parser_vars->m_parser_type = parser_clang_type;
+  parser_vars->m_named_decl = var_decl;
+  parser_vars->m_llvm_value = NULL;
+  parser_vars->m_lldb_value.Clear();
+  entity->m_flags |= ClangExpressionVariable::EVBareRegister;
+
+  if (log) {
+    ASTDumper ast_dumper(var_decl);
+    log->Printf("  CEDM::FEVD[%d] Added register %s, returned %s", current_id,
+                context.m_decl_name.getAsString().c_str(),
+                ast_dumper.GetCString());
+  }
 }
 
-void
-ClangExpressionDeclMap::AddOneFunction (NameSearchContext &context,
-                                        Function* function,
-                                        Symbol* symbol,
-                                        unsigned int current_id)
-{
-    assert (m_parser_vars.get());
-
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-
-    NamedDecl *function_decl = NULL;
-    Address fun_address;
-    CompilerType function_clang_type;
-
-    bool is_indirect_function = false;
-
-    if (function)
-    {
-        Type *function_type = function->GetType();
-        
-        const lldb::LanguageType comp_unit_language = function->GetCompileUnit()->GetLanguage();
-        const bool extern_c = Language::LanguageIsC(comp_unit_language) ||
-                              (Language::LanguageIsObjC(comp_unit_language) &&
-                               !Language::LanguageIsCPlusPlus(comp_unit_language));
-        
-        if (!extern_c)
-        {
-            TypeSystem *type_system = function->GetDeclContext().GetTypeSystem();
-            if (ClangASTContext *src_ast = llvm::dyn_cast<ClangASTContext>(type_system))
-            {
-                clang::DeclContext *src_decl_context = (clang::DeclContext*)function->GetDeclContext().GetOpaqueDeclContext();
-                clang::FunctionDecl *src_function_decl = llvm::dyn_cast_or_null<clang::FunctionDecl>(src_decl_context);
-                
-                if (src_function_decl)
-                {
-                    if (clang::FunctionDecl *copied_function_decl = llvm::dyn_cast_or_null<clang::FunctionDecl>(m_ast_importer_sp->CopyDecl(m_ast_context, src_ast->getASTContext(), src_function_decl)))
-                    {
-                        if (log)
-                        {
-                            ASTDumper ast_dumper((clang::Decl*)copied_function_decl);
-                            
-                            StreamString ss;
-                            
-                            function->DumpSymbolContext(&ss);
-
-                            log->Printf("  CEDM::FEVD[%u] Imported decl for function %s (description %s), returned %s",
-                                        current_id, copied_function_decl->getNameAsString().c_str(), ss.GetData(),
-                                        ast_dumper.GetCString());
-                        }
-                        
-                        context.AddNamedDecl(copied_function_decl);
-                        return;
-                    }
-                    else
-                    {
-                        if (log)
-                        {
-                            log->Printf ("  Failed to import the function decl for '%s'",
-                                         src_function_decl->getName().str().c_str());
-                        }
-                    }
-                }
+void ClangExpressionDeclMap::AddOneFunction(NameSearchContext &context,
+                                            Function *function, Symbol *symbol,
+                                            unsigned int current_id) {
+  assert(m_parser_vars.get());
+
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+
+  NamedDecl *function_decl = NULL;
+  Address fun_address;
+  CompilerType function_clang_type;
+
+  bool is_indirect_function = false;
+
+  if (function) {
+    Type *function_type = function->GetType();
+
+    const lldb::LanguageType comp_unit_language =
+        function->GetCompileUnit()->GetLanguage();
+    const bool extern_c = Language::LanguageIsC(comp_unit_language) ||
+                          (Language::LanguageIsObjC(comp_unit_language) &&
+                           !Language::LanguageIsCPlusPlus(comp_unit_language));
+
+    if (!extern_c) {
+      TypeSystem *type_system = function->GetDeclContext().GetTypeSystem();
+      if (ClangASTContext *src_ast =
+              llvm::dyn_cast<ClangASTContext>(type_system)) {
+        clang::DeclContext *src_decl_context =
+            (clang::DeclContext *)function->GetDeclContext()
+                .GetOpaqueDeclContext();
+        clang::FunctionDecl *src_function_decl =
+            llvm::dyn_cast_or_null<clang::FunctionDecl>(src_decl_context);
+
+        if (src_function_decl) {
+          if (clang::FunctionDecl *copied_function_decl =
+                  llvm::dyn_cast_or_null<clang::FunctionDecl>(
+                      m_ast_importer_sp->CopyDecl(m_ast_context,
+                                                  src_ast->getASTContext(),
+                                                  src_function_decl))) {
+            if (log) {
+              ASTDumper ast_dumper((clang::Decl *)copied_function_decl);
+
+              StreamString ss;
+
+              function->DumpSymbolContext(&ss);
+
+              log->Printf("  CEDM::FEVD[%u] Imported decl for function %s "
+                          "(description %s), returned %s",
+                          current_id,
+                          copied_function_decl->getNameAsString().c_str(),
+                          ss.GetData(), ast_dumper.GetCString());
             }
-        }
 
-        if (!function_type)
-        {
-            if (log)
-                log->PutCString("  Skipped a function because it has no type");
+            context.AddNamedDecl(copied_function_decl);
             return;
+          } else {
+            if (log) {
+              log->Printf("  Failed to import the function decl for '%s'",
+                          src_function_decl->getName().str().c_str());
+            }
+          }
         }
+      }
+    }
 
-        function_clang_type = function_type->GetFullCompilerType ();
+    if (!function_type) {
+      if (log)
+        log->PutCString("  Skipped a function because it has no type");
+      return;
+    }
 
-        if (!function_clang_type)
-        {
-            if (log)
-                log->PutCString("  Skipped a function because it has no Clang type");
-            return;
-        }
+    function_clang_type = function_type->GetFullCompilerType();
 
-        fun_address = function->GetAddressRange().GetBaseAddress();
+    if (!function_clang_type) {
+      if (log)
+        log->PutCString("  Skipped a function because it has no Clang type");
+      return;
+    }
 
-        CompilerType copied_function_type = GuardedCopyType(function_clang_type);
-        if (copied_function_type)
-        {
-            function_decl = context.AddFunDecl(copied_function_type, extern_c);
+    fun_address = function->GetAddressRange().GetBaseAddress();
 
-            if (!function_decl)
-            {
-                if (log)
-                {
-                    log->Printf ("  Failed to create a function decl for '%s' {0x%8.8" PRIx64 "}",
-                                 function_type->GetName().GetCString(),
-                                 function_type->GetID());
-                }
+    CompilerType copied_function_type = GuardedCopyType(function_clang_type);
+    if (copied_function_type) {
+      function_decl = context.AddFunDecl(copied_function_type, extern_c);
 
-                return;
-            }
+      if (!function_decl) {
+        if (log) {
+          log->Printf(
+              "  Failed to create a function decl for '%s' {0x%8.8" PRIx64 "}",
+              function_type->GetName().GetCString(), function_type->GetID());
         }
-        else
-        {
-            // We failed to copy the type we found
-            if (log)
-            {
-                log->Printf ("  Failed to import the function type '%s' {0x%8.8" PRIx64 "} into the expression parser AST contenxt",
-                             function_type->GetName().GetCString(),
-                             function_type->GetID());
-            }
 
-            return;
-        }
-    }
-    else if (symbol)
-    {
-        fun_address = symbol->GetAddress();
-        function_decl = context.AddGenericFunDecl();
-        is_indirect_function = symbol->IsIndirect();
-    }
-    else
-    {
-        if (log)
-            log->PutCString("  AddOneFunction called with no function and no symbol");
         return;
+      }
+    } else {
+      // We failed to copy the type we found
+      if (log) {
+        log->Printf("  Failed to import the function type '%s' {0x%8.8" PRIx64
+                    "} into the expression parser AST contenxt",
+                    function_type->GetName().GetCString(),
+                    function_type->GetID());
+      }
+
+      return;
     }
+  } else if (symbol) {
+    fun_address = symbol->GetAddress();
+    function_decl = context.AddGenericFunDecl();
+    is_indirect_function = symbol->IsIndirect();
+  } else {
+    if (log)
+      log->PutCString("  AddOneFunction called with no function and no symbol");
+    return;
+  }
 
-    Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
-
-    lldb::addr_t load_addr = fun_address.GetCallableLoadAddress(target, is_indirect_function);
+  Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
 
-    ClangExpressionVariable *entity(new ClangExpressionVariable (m_parser_vars->m_exe_ctx.GetBestExecutionContextScope (),
-                                                                 m_parser_vars->m_target_info.byte_order,
-                                                                 m_parser_vars->m_target_info.address_byte_size));
-    m_found_entities.AddNewlyConstructedVariable(entity);
+  lldb::addr_t load_addr =
+      fun_address.GetCallableLoadAddress(target, is_indirect_function);
 
-    std::string decl_name(context.m_decl_name.getAsString());
-    entity->SetName(ConstString(decl_name.c_str()));
-    entity->SetCompilerType (function_clang_type);
-    entity->EnableParserVars(GetParserID());
+  ClangExpressionVariable *entity(new ClangExpressionVariable(
+      m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
+      m_parser_vars->m_target_info.byte_order,
+      m_parser_vars->m_target_info.address_byte_size));
+  m_found_entities.AddNewlyConstructedVariable(entity);
 
-    ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
+  std::string decl_name(context.m_decl_name.getAsString());
+  entity->SetName(ConstString(decl_name.c_str()));
+  entity->SetCompilerType(function_clang_type);
+  entity->EnableParserVars(GetParserID());
 
-    if (load_addr != LLDB_INVALID_ADDRESS)
-    {
-        parser_vars->m_lldb_value.SetValueType(Value::eValueTypeLoadAddress);
-        parser_vars->m_lldb_value.GetScalar() = load_addr;
-    }
-    else
-    {
-        // We have to try finding a file address.
+  ClangExpressionVariable::ParserVars *parser_vars =
+      entity->GetParserVars(GetParserID());
 
-        lldb::addr_t file_addr = fun_address.GetFileAddress();
+  if (load_addr != LLDB_INVALID_ADDRESS) {
+    parser_vars->m_lldb_value.SetValueType(Value::eValueTypeLoadAddress);
+    parser_vars->m_lldb_value.GetScalar() = load_addr;
+  } else {
+    // We have to try finding a file address.
 
-        parser_vars->m_lldb_value.SetValueType(Value::eValueTypeFileAddress);
-        parser_vars->m_lldb_value.GetScalar() = file_addr;
-    }
+    lldb::addr_t file_addr = fun_address.GetFileAddress();
 
+    parser_vars->m_lldb_value.SetValueType(Value::eValueTypeFileAddress);
+    parser_vars->m_lldb_value.GetScalar() = file_addr;
+  }
 
-    parser_vars->m_named_decl  = function_decl;
-    parser_vars->m_llvm_value  = NULL;
+  parser_vars->m_named_decl = function_decl;
+  parser_vars->m_llvm_value = NULL;
 
-    if (log)
-    {
-        ASTDumper ast_dumper(function_decl);
+  if (log) {
+    ASTDumper ast_dumper(function_decl);
 
-        StreamString ss;
+    StreamString ss;
 
-        fun_address.Dump(&ss, m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(), Address::DumpStyleResolvedDescription);
+    fun_address.Dump(&ss,
+                     m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
+                     Address::DumpStyleResolvedDescription);
 
-        log->Printf("  CEDM::FEVD[%u] Found %s function %s (description %s), returned %s",
-                    current_id,
-                    (function ? "specific" : "generic"),
-                    decl_name.c_str(),
-                    ss.GetData(),
-                    ast_dumper.GetCString());
-    }
+    log->Printf(
+        "  CEDM::FEVD[%u] Found %s function %s (description %s), returned %s",
+        current_id, (function ? "specific" : "generic"), decl_name.c_str(),
+        ss.GetData(), ast_dumper.GetCString());
+  }
 }
 
-void
-ClangExpressionDeclMap::AddThisType(NameSearchContext &context,
-                                    TypeFromUser &ut,
-                                    unsigned int current_id)
-{
-    CompilerType copied_clang_type = GuardedCopyType(ut);
+void ClangExpressionDeclMap::AddThisType(NameSearchContext &context,
+                                         TypeFromUser &ut,
+                                         unsigned int current_id) {
+  CompilerType copied_clang_type = GuardedCopyType(ut);
 
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    if (!copied_clang_type)
-    {
-        if (log)
-            log->Printf("ClangExpressionDeclMap::AddThisType - Couldn't import the type");
+  if (!copied_clang_type) {
+    if (log)
+      log->Printf(
+          "ClangExpressionDeclMap::AddThisType - Couldn't import the type");
 
-        return;
+    return;
+  }
+
+  if (copied_clang_type.IsAggregateType() &&
+      copied_clang_type.GetCompleteType()) {
+    CompilerType void_clang_type =
+        ClangASTContext::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, 0);
+
+    const bool is_virtual = false;
+    const bool is_static = false;
+    const bool is_inline = false;
+    const bool is_explicit = false;
+    const bool is_attr_used = true;
+    const bool is_artificial = false;
+
+    CXXMethodDecl *method_decl =
+        ClangASTContext::GetASTContext(m_ast_context)
+            ->AddMethodToCXXRecordType(
+                copied_clang_type.GetOpaqueQualType(), "$__lldb_expr",
+                method_type, lldb::eAccessPublic, is_virtual, is_static,
+                is_inline, is_explicit, is_attr_used, is_artificial);
+
+    if (log) {
+      ASTDumper method_ast_dumper((clang::Decl *)method_decl);
+      ASTDumper type_ast_dumper(copied_clang_type);
+
+      log->Printf("  CEDM::AddThisType Added function $__lldb_expr "
+                  "(description %s) for this type %s",
+                  method_ast_dumper.GetCString(), type_ast_dumper.GetCString());
     }
+  }
 
-    if (copied_clang_type.IsAggregateType() && copied_clang_type.GetCompleteType ())
-    {
-        CompilerType void_clang_type = ClangASTContext::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,
-                                                                        0);
-
-        const bool is_virtual = false;
-        const bool is_static = false;
-        const bool is_inline = false;
-        const bool is_explicit = false;
-        const bool is_attr_used = true;
-        const bool is_artificial = false;
-
-        CXXMethodDecl *method_decl = ClangASTContext::GetASTContext(m_ast_context)->
-            AddMethodToCXXRecordType (copied_clang_type.GetOpaqueQualType(),
-                                      "$__lldb_expr",
-                                      method_type,
-                                      lldb::eAccessPublic,
-                                      is_virtual,
-                                      is_static,
-                                      is_inline,
-                                      is_explicit,
-                                      is_attr_used,
-                                      is_artificial);
-        
-        if (log)
-        {
-            ASTDumper method_ast_dumper((clang::Decl*)method_decl);
-            ASTDumper type_ast_dumper(copied_clang_type);
-        
-            log->Printf("  CEDM::AddThisType Added function $__lldb_expr (description %s) for this type %s",
-                        method_ast_dumper.GetCString(),
-                        type_ast_dumper.GetCString());
-        }
-    }
+  if (!copied_clang_type.IsValid())
+    return;
 
-    if (!copied_clang_type.IsValid())
-        return;
-    
-    TypeSourceInfo *type_source_info = m_ast_context->getTrivialTypeSourceInfo(QualType::getFromOpaquePtr(copied_clang_type.GetOpaqueQualType()));
-    
-    if (!type_source_info)
-        return;
-    
-    // Construct a typedef type because if "*this" is a templated type we can't just return ClassTemplateSpecializationDecls in response to name queries.
-    // Using a typedef makes this much more robust.
-    
-    TypedefDecl *typedef_decl = TypedefDecl::Create(*m_ast_context,
-                                                    m_ast_context->getTranslationUnitDecl(),
-                                                    SourceLocation(),
-                                                    SourceLocation(),
-                                                    context.m_decl_name.getAsIdentifierInfo(),
-                                                    type_source_info);
-    
-    
-    if (!typedef_decl)
-        return;
-    
-    context.AddNamedDecl(typedef_decl);
+  TypeSourceInfo *type_source_info = m_ast_context->getTrivialTypeSourceInfo(
+      QualType::getFromOpaquePtr(copied_clang_type.GetOpaqueQualType()));
 
+  if (!type_source_info)
     return;
+
+  // Construct a typedef type because if "*this" is a templated type we can't
+  // just return ClassTemplateSpecializationDecls in response to name queries.
+  // Using a typedef makes this much more robust.
+
+  TypedefDecl *typedef_decl = TypedefDecl::Create(
+      *m_ast_context, m_ast_context->getTranslationUnitDecl(), SourceLocation(),
+      SourceLocation(), context.m_decl_name.getAsIdentifierInfo(),
+      type_source_info);
+
+  if (!typedef_decl)
+    return;
+
+  context.AddNamedDecl(typedef_decl);
+
+  return;
 }
 
-void
-ClangExpressionDeclMap::AddOneType(NameSearchContext &context,
-                                   TypeFromUser &ut,
-                                   unsigned int current_id)
-{
-    CompilerType copied_clang_type = GuardedCopyType(ut);
+void ClangExpressionDeclMap::AddOneType(NameSearchContext &context,
+                                        TypeFromUser &ut,
+                                        unsigned int current_id) {
+  CompilerType copied_clang_type = GuardedCopyType(ut);
 
-    if (!copied_clang_type)
-    {
-        Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+  if (!copied_clang_type) {
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-        if (log)
-            log->Printf("ClangExpressionDeclMap::AddOneType - Couldn't import the type");
+    if (log)
+      log->Printf(
+          "ClangExpressionDeclMap::AddOneType - Couldn't import the type");
 
-        return;
-    }
+    return;
+  }
 
-    context.AddTypeDecl(copied_clang_type);
+  context.AddTypeDecl(copied_clang_type);
 }