*** 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, 525 insertions, 568 deletions

diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp
index 52d49ae..c456e41 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp
@@ -9,21 +9,21 @@
 
 #include <stdio.h>
 #if HAVE_SYS_TYPES_H
-#  include <sys/types.h>
+#include <sys/types.h>
 #endif
 
 #include <cstdlib>
-#include <string>
 #include <map>
+#include <string>
 
 #include "ClangUserExpression.h"
 
 #include "ASTResultSynthesizer.h"
+#include "ClangDiagnostic.h"
 #include "ClangExpressionDeclMap.h"
 #include "ClangExpressionParser.h"
 #include "ClangModulesDeclVendor.h"
 #include "ClangPersistentVariables.h"
-#include "ClangDiagnostic.h"
 
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/Debugger.h"
@@ -39,11 +39,11 @@
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
-#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
@@ -57,676 +57,633 @@
 
 using namespace lldb_private;
 
-ClangUserExpression::ClangUserExpression(ExecutionContextScope &exe_scope, const char *expr, const char *expr_prefix,
-                                         lldb::LanguageType language, ResultType desired_type,
-                                         const EvaluateExpressionOptions &options)
-    : LLVMUserExpression(exe_scope, expr, expr_prefix, language, desired_type, options),
-      m_type_system_helper(*m_target_wp.lock().get(), options.GetExecutionPolicy() == eExecutionPolicyTopLevel)
-{
-    switch (m_language)
-    {
-        case lldb::eLanguageTypeC_plus_plus:
-            m_allow_cxx = true;
-            break;
-        case lldb::eLanguageTypeObjC:
-            m_allow_objc = true;
-            break;
-        case lldb::eLanguageTypeObjC_plus_plus:
-        default:
-            m_allow_cxx = true;
-            m_allow_objc = true;
-            break;
-    }
+ClangUserExpression::ClangUserExpression(
+    ExecutionContextScope &exe_scope, const char *expr, const char *expr_prefix,
+    lldb::LanguageType language, ResultType desired_type,
+    const EvaluateExpressionOptions &options)
+    : LLVMUserExpression(exe_scope, expr, expr_prefix, language, desired_type,
+                         options),
+      m_type_system_helper(*m_target_wp.lock().get(),
+                           options.GetExecutionPolicy() ==
+                               eExecutionPolicyTopLevel) {
+  switch (m_language) {
+  case lldb::eLanguageTypeC_plus_plus:
+    m_allow_cxx = true;
+    break;
+  case lldb::eLanguageTypeObjC:
+    m_allow_objc = true;
+    break;
+  case lldb::eLanguageTypeObjC_plus_plus:
+  default:
+    m_allow_cxx = true;
+    m_allow_objc = true;
+    break;
+  }
 }
 
-ClangUserExpression::~ClangUserExpression ()
-{
-}
+ClangUserExpression::~ClangUserExpression() {}
+
+void ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-void
-ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+  if (log)
+    log->Printf("ClangUserExpression::ScanContext()");
 
+  m_target = exe_ctx.GetTargetPtr();
+
+  if (!(m_allow_cxx || m_allow_objc)) {
     if (log)
-        log->Printf("ClangUserExpression::ScanContext()");
+      log->Printf("  [CUE::SC] Settings inhibit C++ and Objective-C");
+    return;
+  }
 
-    m_target = exe_ctx.GetTargetPtr();
+  StackFrame *frame = exe_ctx.GetFramePtr();
+  if (frame == NULL) {
+    if (log)
+      log->Printf("  [CUE::SC] Null stack frame");
+    return;
+  }
 
-    if (!(m_allow_cxx || m_allow_objc))
-    {
-        if (log)
-            log->Printf("  [CUE::SC] Settings inhibit C++ and Objective-C");
-        return;
-    }
+  SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
+                                                  lldb::eSymbolContextBlock);
 
-    StackFrame *frame = exe_ctx.GetFramePtr();
-    if (frame == NULL)
-    {
-        if (log)
-            log->Printf("  [CUE::SC] Null stack frame");
-        return;
-    }
+  if (!sym_ctx.function) {
+    if (log)
+      log->Printf("  [CUE::SC] Null function");
+    return;
+  }
 
-    SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction | lldb::eSymbolContextBlock);
+  // Find the block that defines the function represented by "sym_ctx"
+  Block *function_block = sym_ctx.GetFunctionBlock();
 
-    if (!sym_ctx.function)
-    {
-        if (log)
-            log->Printf("  [CUE::SC] Null function");
-        return;
-    }
+  if (!function_block) {
+    if (log)
+      log->Printf("  [CUE::SC] Null function block");
+    return;
+  }
 
-    // Find the block that defines the function represented by "sym_ctx"
-    Block *function_block = sym_ctx.GetFunctionBlock();
+  CompilerDeclContext decl_context = function_block->GetDeclContext();
 
-    if (!function_block)
-    {
-        if (log)
-            log->Printf("  [CUE::SC] Null function block");
-        return;
-    }
+  if (!decl_context) {
+    if (log)
+      log->Printf("  [CUE::SC] Null decl context");
+    return;
+  }
+
+  if (clang::CXXMethodDecl *method_decl =
+          ClangASTContext::DeclContextGetAsCXXMethodDecl(decl_context)) {
+    if (m_allow_cxx && method_decl->isInstance()) {
+      if (m_enforce_valid_object) {
+        lldb::VariableListSP variable_list_sp(
+            function_block->GetBlockVariableList(true));
+
+        const char *thisErrorString = "Stopped in a C++ method, but 'this' "
+                                      "isn't available; pretending we are in a "
+                                      "generic context";
+
+        if (!variable_list_sp) {
+          err.SetErrorString(thisErrorString);
+          return;
+        }
 
-    CompilerDeclContext decl_context = function_block->GetDeclContext();
+        lldb::VariableSP this_var_sp(
+            variable_list_sp->FindVariable(ConstString("this")));
+
+        if (!this_var_sp || !this_var_sp->IsInScope(frame) ||
+            !this_var_sp->LocationIsValidForFrame(frame)) {
+          err.SetErrorString(thisErrorString);
+          return;
+        }
+      }
 
-    if (!decl_context)
-    {
-        if (log)
-            log->Printf("  [CUE::SC] Null decl context");
-        return;
+      m_in_cplusplus_method = true;
+      m_needs_object_ptr = true;
     }
+  } else if (clang::ObjCMethodDecl *method_decl =
+                 ClangASTContext::DeclContextGetAsObjCMethodDecl(
+                     decl_context)) {
+    if (m_allow_objc) {
+      if (m_enforce_valid_object) {
+        lldb::VariableListSP variable_list_sp(
+            function_block->GetBlockVariableList(true));
+
+        const char *selfErrorString = "Stopped in an Objective-C method, but "
+                                      "'self' isn't available; pretending we "
+                                      "are in a generic context";
+
+        if (!variable_list_sp) {
+          err.SetErrorString(selfErrorString);
+          return;
+        }
 
-    if (clang::CXXMethodDecl *method_decl = ClangASTContext::DeclContextGetAsCXXMethodDecl(decl_context))
-    {
-        if (m_allow_cxx && method_decl->isInstance())
-        {
-            if (m_enforce_valid_object)
-            {
-                lldb::VariableListSP variable_list_sp (function_block->GetBlockVariableList (true));
-
-                const char *thisErrorString = "Stopped in a C++ method, but 'this' isn't available; pretending we are in a generic context";
-
-                if (!variable_list_sp)
-                {
-                    err.SetErrorString(thisErrorString);
-                    return;
-                }
-
-                lldb::VariableSP this_var_sp (variable_list_sp->FindVariable(ConstString("this")));
-
-                if (!this_var_sp ||
-                    !this_var_sp->IsInScope(frame) ||
-                    !this_var_sp->LocationIsValidForFrame (frame))
-                {
-                    err.SetErrorString(thisErrorString);
-                    return;
-                }
-            }
-
-            m_in_cplusplus_method = true;
-            m_needs_object_ptr = true;
+        lldb::VariableSP self_variable_sp =
+            variable_list_sp->FindVariable(ConstString("self"));
+
+        if (!self_variable_sp || !self_variable_sp->IsInScope(frame) ||
+            !self_variable_sp->LocationIsValidForFrame(frame)) {
+          err.SetErrorString(selfErrorString);
+          return;
         }
+      }
+
+      m_in_objectivec_method = true;
+      m_needs_object_ptr = true;
+
+      if (!method_decl->isInstanceMethod())
+        m_in_static_method = true;
     }
-    else if (clang::ObjCMethodDecl *method_decl = ClangASTContext::DeclContextGetAsObjCMethodDecl(decl_context))
-    {
-        if (m_allow_objc)
-        {
-            if (m_enforce_valid_object)
-            {
-                lldb::VariableListSP variable_list_sp (function_block->GetBlockVariableList (true));
-
-                const char *selfErrorString = "Stopped in an Objective-C method, but 'self' isn't available; pretending we are in a generic context";
-
-                if (!variable_list_sp)
-                {
-                    err.SetErrorString(selfErrorString);
-                    return;
-                }
-
-                lldb::VariableSP self_variable_sp = variable_list_sp->FindVariable(ConstString("self"));
-
-                if (!self_variable_sp ||
-                    !self_variable_sp->IsInScope(frame) ||
-                    !self_variable_sp->LocationIsValidForFrame (frame))
-                {
-                    err.SetErrorString(selfErrorString);
-                    return;
-                }
-            }
+  } else if (clang::FunctionDecl *function_decl =
+                 ClangASTContext::DeclContextGetAsFunctionDecl(decl_context)) {
+    // We might also have a function that said in the debug information that it
+    // captured an
+    // object pointer.  The best way to deal with getting to the ivars at
+    // present is by pretending
+    // that this is a method of a class in whatever runtime the debug info says
+    // the object pointer
+    // belongs to.  Do that here.
+
+    ClangASTMetadata *metadata =
+        ClangASTContext::DeclContextGetMetaData(decl_context, function_decl);
+    if (metadata && metadata->HasObjectPtr()) {
+      lldb::LanguageType language = metadata->GetObjectPtrLanguage();
+      if (language == lldb::eLanguageTypeC_plus_plus) {
+        if (m_enforce_valid_object) {
+          lldb::VariableListSP variable_list_sp(
+              function_block->GetBlockVariableList(true));
+
+          const char *thisErrorString = "Stopped in a context claiming to "
+                                        "capture a C++ object pointer, but "
+                                        "'this' isn't available; pretending we "
+                                        "are in a generic context";
+
+          if (!variable_list_sp) {
+            err.SetErrorString(thisErrorString);
+            return;
+          }
+
+          lldb::VariableSP this_var_sp(
+              variable_list_sp->FindVariable(ConstString("this")));
+
+          if (!this_var_sp || !this_var_sp->IsInScope(frame) ||
+              !this_var_sp->LocationIsValidForFrame(frame)) {
+            err.SetErrorString(thisErrorString);
+            return;
+          }
+        }
 
+        m_in_cplusplus_method = true;
+        m_needs_object_ptr = true;
+      } else if (language == lldb::eLanguageTypeObjC) {
+        if (m_enforce_valid_object) {
+          lldb::VariableListSP variable_list_sp(
+              function_block->GetBlockVariableList(true));
+
+          const char *selfErrorString =
+              "Stopped in a context claiming to capture an Objective-C object "
+              "pointer, but 'self' isn't available; pretending we are in a "
+              "generic context";
+
+          if (!variable_list_sp) {
+            err.SetErrorString(selfErrorString);
+            return;
+          }
+
+          lldb::VariableSP self_variable_sp =
+              variable_list_sp->FindVariable(ConstString("self"));
+
+          if (!self_variable_sp || !self_variable_sp->IsInScope(frame) ||
+              !self_variable_sp->LocationIsValidForFrame(frame)) {
+            err.SetErrorString(selfErrorString);
+            return;
+          }
+
+          Type *self_type = self_variable_sp->GetType();
+
+          if (!self_type) {
+            err.SetErrorString(selfErrorString);
+            return;
+          }
+
+          CompilerType self_clang_type = self_type->GetForwardCompilerType();
+
+          if (!self_clang_type) {
+            err.SetErrorString(selfErrorString);
+            return;
+          }
+
+          if (ClangASTContext::IsObjCClassType(self_clang_type)) {
+            return;
+          } else if (ClangASTContext::IsObjCObjectPointerType(
+                         self_clang_type)) {
             m_in_objectivec_method = true;
             m_needs_object_ptr = true;
-
-            if (!method_decl->isInstanceMethod())
-                m_in_static_method = true;
-        }
-    }
-    else if (clang::FunctionDecl *function_decl = ClangASTContext::DeclContextGetAsFunctionDecl(decl_context))
-    {
-        // We might also have a function that said in the debug information that it captured an
-        // object pointer.  The best way to deal with getting to the ivars at present is by pretending
-        // that this is a method of a class in whatever runtime the debug info says the object pointer
-        // belongs to.  Do that here.
-
-        ClangASTMetadata *metadata = ClangASTContext::DeclContextGetMetaData (decl_context, function_decl);
-        if (metadata && metadata->HasObjectPtr())
-        {
-            lldb::LanguageType language = metadata->GetObjectPtrLanguage();
-            if (language == lldb::eLanguageTypeC_plus_plus)
-            {
-                if (m_enforce_valid_object)
-                {
-                    lldb::VariableListSP variable_list_sp (function_block->GetBlockVariableList (true));
-
-                    const char *thisErrorString = "Stopped in a context claiming to capture a C++ object pointer, but 'this' isn't available; pretending we are in a generic context";
-
-                    if (!variable_list_sp)
-                    {
-                        err.SetErrorString(thisErrorString);
-                        return;
-                    }
-
-                    lldb::VariableSP this_var_sp (variable_list_sp->FindVariable(ConstString("this")));
-
-                    if (!this_var_sp ||
-                        !this_var_sp->IsInScope(frame) ||
-                        !this_var_sp->LocationIsValidForFrame (frame))
-                    {
-                        err.SetErrorString(thisErrorString);
-                        return;
-                    }
-                }
-
-                m_in_cplusplus_method = true;
-                m_needs_object_ptr = true;
-            }
-            else if (language == lldb::eLanguageTypeObjC)
-            {
-                if (m_enforce_valid_object)
-                {
-                    lldb::VariableListSP variable_list_sp (function_block->GetBlockVariableList (true));
-
-                    const char *selfErrorString = "Stopped in a context claiming to capture an Objective-C object pointer, but 'self' isn't available; pretending we are in a generic context";
-
-                    if (!variable_list_sp)
-                    {
-                        err.SetErrorString(selfErrorString);
-                        return;
-                    }
-
-                    lldb::VariableSP self_variable_sp = variable_list_sp->FindVariable(ConstString("self"));
-
-                    if (!self_variable_sp ||
-                        !self_variable_sp->IsInScope(frame) ||
-                        !self_variable_sp->LocationIsValidForFrame (frame))
-                    {
-                        err.SetErrorString(selfErrorString);
-                        return;
-                    }
-
-                    Type *self_type = self_variable_sp->GetType();
-
-                    if (!self_type)
-                    {
-                        err.SetErrorString(selfErrorString);
-                        return;
-                    }
-
-                    CompilerType self_clang_type = self_type->GetForwardCompilerType ();
-
-                    if (!self_clang_type)
-                    {
-                        err.SetErrorString(selfErrorString);
-                        return;
-                    }
-
-                    if (ClangASTContext::IsObjCClassType(self_clang_type))
-                    {
-                        return;
-                    }
-                    else if (ClangASTContext::IsObjCObjectPointerType(self_clang_type))
-                    {
-                        m_in_objectivec_method = true;
-                        m_needs_object_ptr = true;
-                    }
-                    else
-                    {
-                        err.SetErrorString(selfErrorString);
-                        return;
-                    }
-                }
-                else
-                {
-                    m_in_objectivec_method = true;
-                    m_needs_object_ptr = true;
-                }
-            }
+          } else {
+            err.SetErrorString(selfErrorString);
+            return;
+          }
+        } else {
+          m_in_objectivec_method = true;
+          m_needs_object_ptr = true;
         }
+      }
     }
+  }
 }
 
 // This is a really nasty hack, meant to fix Objective-C expressions of the form
 // (int)[myArray count].  Right now, because the type information for count is
 // not available, [myArray count] returns id, which can't be directly cast to
 // int without causing a clang error.
-static void
-ApplyObjcCastHack(std::string &expr)
-{
+static void ApplyObjcCastHack(std::string &expr) {
 #define OBJC_CAST_HACK_FROM "(int)["
-#define OBJC_CAST_HACK_TO   "(int)(long long)["
+#define OBJC_CAST_HACK_TO "(int)(long long)["
 
-    size_t from_offset;
+  size_t from_offset;
 
-    while ((from_offset = expr.find(OBJC_CAST_HACK_FROM)) != expr.npos)
-        expr.replace(from_offset, sizeof(OBJC_CAST_HACK_FROM) - 1, OBJC_CAST_HACK_TO);
+  while ((from_offset = expr.find(OBJC_CAST_HACK_FROM)) != expr.npos)
+    expr.replace(from_offset, sizeof(OBJC_CAST_HACK_FROM) - 1,
+                 OBJC_CAST_HACK_TO);
 
 #undef OBJC_CAST_HACK_TO
 #undef OBJC_CAST_HACK_FROM
 }
 
-bool
-ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
-                           lldb_private::ExecutionPolicy execution_policy, bool keep_result_in_memory,
-                           bool generate_debug_info)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-
-    Error err;
-
-    InstallContext(exe_ctx);
-    
-    if (Target *target = exe_ctx.GetTargetPtr())
-    {
-        if (PersistentExpressionState *persistent_state = target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC))
-        {
-            m_result_delegate.RegisterPersistentState(persistent_state);
-        }
-        else
-        {
-            diagnostic_manager.PutCString(eDiagnosticSeverityError, "couldn't start parsing (no persistent data)");
-            return false;
-        }
+bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager,
+                                ExecutionContext &exe_ctx,
+                                lldb_private::ExecutionPolicy execution_policy,
+                                bool keep_result_in_memory,
+                                bool generate_debug_info) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+
+  Error err;
+
+  InstallContext(exe_ctx);
+
+  if (Target *target = exe_ctx.GetTargetPtr()) {
+    if (PersistentExpressionState *persistent_state =
+            target->GetPersistentExpressionStateForLanguage(
+                lldb::eLanguageTypeC)) {
+      m_result_delegate.RegisterPersistentState(persistent_state);
+    } else {
+      diagnostic_manager.PutCString(
+          eDiagnosticSeverityError,
+          "couldn't start parsing (no persistent data)");
+      return false;
     }
-    else
-    {
-        diagnostic_manager.PutCString(eDiagnosticSeverityError, "error: couldn't start parsing (no target)");
-        return false;
+  } else {
+    diagnostic_manager.PutCString(eDiagnosticSeverityError,
+                                  "error: couldn't start parsing (no target)");
+    return false;
+  }
+
+  ScanContext(exe_ctx, err);
+
+  if (!err.Success()) {
+    diagnostic_manager.PutCString(eDiagnosticSeverityWarning, err.AsCString());
+  }
+
+  ////////////////////////////////////
+  // Generate the expression
+  //
+
+  ApplyObjcCastHack(m_expr_text);
+  // ApplyUnicharHack(m_expr_text);
+
+  std::string prefix = m_expr_prefix;
+
+  if (ClangModulesDeclVendor *decl_vendor =
+          m_target->GetClangModulesDeclVendor()) {
+    const ClangModulesDeclVendor::ModuleVector &hand_imported_modules =
+        llvm::cast<ClangPersistentVariables>(
+            m_target->GetPersistentExpressionStateForLanguage(
+                lldb::eLanguageTypeC))
+            ->GetHandLoadedClangModules();
+    ClangModulesDeclVendor::ModuleVector modules_for_macros;
+
+    for (ClangModulesDeclVendor::ModuleID module : hand_imported_modules) {
+      modules_for_macros.push_back(module);
     }
 
-    ScanContext(exe_ctx, err);
+    if (m_target->GetEnableAutoImportClangModules()) {
+      if (StackFrame *frame = exe_ctx.GetFramePtr()) {
+        if (Block *block = frame->GetFrameBlock()) {
+          SymbolContext sc;
 
-    if (!err.Success())
-    {
-        diagnostic_manager.PutCString(eDiagnosticSeverityWarning, err.AsCString());
-    }
+          block->CalculateSymbolContext(&sc);
 
-    ////////////////////////////////////
-    // Generate the expression
-    //
-
-    ApplyObjcCastHack(m_expr_text);
-    //ApplyUnicharHack(m_expr_text);
-
-    std::string prefix = m_expr_prefix;
-    
-    if (ClangModulesDeclVendor *decl_vendor = m_target->GetClangModulesDeclVendor())
-    {
-        const ClangModulesDeclVendor::ModuleVector &hand_imported_modules = llvm::cast<ClangPersistentVariables>(m_target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC))->GetHandLoadedClangModules();
-        ClangModulesDeclVendor::ModuleVector modules_for_macros;
-        
-        for (ClangModulesDeclVendor::ModuleID module : hand_imported_modules)
-        {
-            modules_for_macros.push_back(module);
-        }
+          if (sc.comp_unit) {
+            StreamString error_stream;
 
-        if (m_target->GetEnableAutoImportClangModules())
-        {
-            if (StackFrame *frame = exe_ctx.GetFramePtr())
-            {
-                if (Block *block = frame->GetFrameBlock())
-                {
-                    SymbolContext sc;
-                    
-                    block->CalculateSymbolContext(&sc);
-                    
-                    if (sc.comp_unit)
-                    {
-                        StreamString error_stream;
-                        
-                        decl_vendor->AddModulesForCompileUnit(*sc.comp_unit, modules_for_macros, error_stream);
-                    }
-                }
-            }
+            decl_vendor->AddModulesForCompileUnit(
+                *sc.comp_unit, modules_for_macros, error_stream);
+          }
         }
+      }
     }
+  }
 
-    lldb::LanguageType lang_type = lldb::eLanguageTypeUnknown;
+  lldb::LanguageType lang_type = lldb::eLanguageTypeUnknown;
 
-    if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel)
-    {
-        m_transformed_text = m_expr_text;
-    }
+  if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
+    m_transformed_text = m_expr_text;
+  } else {
+    std::unique_ptr<ExpressionSourceCode> source_code(
+        ExpressionSourceCode::CreateWrapped(prefix.c_str(),
+                                            m_expr_text.c_str()));
+
+    if (m_in_cplusplus_method)
+      lang_type = lldb::eLanguageTypeC_plus_plus;
+    else if (m_in_objectivec_method)
+      lang_type = lldb::eLanguageTypeObjC;
     else
-    {
-        std::unique_ptr<ExpressionSourceCode> source_code(
-            ExpressionSourceCode::CreateWrapped(prefix.c_str(), m_expr_text.c_str()));
-
-        if (m_in_cplusplus_method)
-            lang_type = lldb::eLanguageTypeC_plus_plus;
-        else if (m_in_objectivec_method)
-            lang_type = lldb::eLanguageTypeObjC;
-        else
-            lang_type = lldb::eLanguageTypeC;
-
-        if (!source_code->GetText(m_transformed_text, lang_type, m_in_static_method, exe_ctx))
-        {
-            diagnostic_manager.PutCString(eDiagnosticSeverityError, "couldn't construct expression body");
-            return false;
-        }
+      lang_type = lldb::eLanguageTypeC;
+
+    if (!source_code->GetText(m_transformed_text, lang_type, m_in_static_method,
+                              exe_ctx)) {
+      diagnostic_manager.PutCString(eDiagnosticSeverityError,
+                                    "couldn't construct expression body");
+      return false;
     }
+  }
 
-    if (log)
-        log->Printf("Parsing the following code:\n%s", m_transformed_text.c_str());
+  if (log)
+    log->Printf("Parsing the following code:\n%s", m_transformed_text.c_str());
 
-    ////////////////////////////////////
-    // Set up the target and compiler
-    //
+  ////////////////////////////////////
+  // Set up the target and compiler
+  //
 
-    Target *target = exe_ctx.GetTargetPtr();
+  Target *target = exe_ctx.GetTargetPtr();
 
-    if (!target)
-    {
-        diagnostic_manager.PutCString(eDiagnosticSeverityError, "invalid target");
-        return false;
-    }
+  if (!target) {
+    diagnostic_manager.PutCString(eDiagnosticSeverityError, "invalid target");
+    return false;
+  }
 
-    //////////////////////////
-    // Parse the expression
-    //
+  //////////////////////////
+  // Parse the expression
+  //
 
-    m_materializer_ap.reset(new Materializer());
+  m_materializer_ap.reset(new Materializer());
 
-    ResetDeclMap(exe_ctx, m_result_delegate, keep_result_in_memory);
+  ResetDeclMap(exe_ctx, m_result_delegate, keep_result_in_memory);
 
-    class OnExit
-    {
-    public:
-        typedef std::function <void (void)> Callback;
+  class OnExit {
+  public:
+    typedef std::function<void(void)> Callback;
 
-        OnExit (Callback const &callback) :
-            m_callback(callback)
-        {
-        }
+    OnExit(Callback const &callback) : m_callback(callback) {}
 
-        ~OnExit ()
-        {
-            m_callback();
-        }
-    private:
-        Callback m_callback;
-    };
+    ~OnExit() { m_callback(); }
 
-    OnExit on_exit([this]() { ResetDeclMap(); });
+  private:
+    Callback m_callback;
+  };
 
-    if (!DeclMap()->WillParse(exe_ctx, m_materializer_ap.get()))
-    {
-        diagnostic_manager.PutCString(eDiagnosticSeverityError,
-                                      "current process state is unsuitable for expression parsing");
+  OnExit on_exit([this]() { ResetDeclMap(); });
 
-        ResetDeclMap(); // We are being careful here in the case of breakpoint conditions.
+  if (!DeclMap()->WillParse(exe_ctx, m_materializer_ap.get())) {
+    diagnostic_manager.PutCString(
+        eDiagnosticSeverityError,
+        "current process state is unsuitable for expression parsing");
 
-        return false;
-    }
+    ResetDeclMap(); // We are being careful here in the case of breakpoint
+                    // conditions.
 
-    if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel)
-    {
-        DeclMap()->SetLookupsEnabled(true);
-    }
+    return false;
+  }
 
-    Process *process = exe_ctx.GetProcessPtr();
-    ExecutionContextScope *exe_scope = process;
-
-    if (!exe_scope)
-        exe_scope = exe_ctx.GetTargetPtr();
-
-    // We use a shared pointer here so we can use the original parser - if it succeeds
-    // or the rewrite parser we might make if it fails.  But the parser_sp will never be empty.
-    
-    ClangExpressionParser parser(exe_scope, *this, generate_debug_info);
-
-    unsigned num_errors = parser.Parse(diagnostic_manager);
-
-    // Check here for FixItHints.  If there are any try to apply the fixits and set the fixed text in m_fixed_text
-    // before returning an error.
-    if (num_errors)
-    {
-        if (diagnostic_manager.HasFixIts())
-        {
-            if (parser.RewriteExpression(diagnostic_manager))
-            {
-                size_t fixed_start;
-                size_t fixed_end;
-                const std::string &fixed_expression = diagnostic_manager.GetFixedExpression();
-                if (ExpressionSourceCode::GetOriginalBodyBounds(fixed_expression, lang_type, fixed_start, fixed_end))
-                    m_fixed_text = fixed_expression.substr(fixed_start, fixed_end - fixed_start);
-            }
-        }
+  if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
+    DeclMap()->SetLookupsEnabled(true);
+  }
 
-        ResetDeclMap(); // We are being careful here in the case of breakpoint conditions.
+  Process *process = exe_ctx.GetProcessPtr();
+  ExecutionContextScope *exe_scope = process;
 
-        return false;
-    }
+  if (!exe_scope)
+    exe_scope = exe_ctx.GetTargetPtr();
 
-    //////////////////////////////////////////////////////////////////////////////////////////
-    // Prepare the output of the parser for execution, evaluating it statically if possible
-    //
-
-    {
-        Error jit_error = parser.PrepareForExecution(m_jit_start_addr,
-                                                     m_jit_end_addr,
-                                                     m_execution_unit_sp,
-                                                     exe_ctx,
-                                                     m_can_interpret,
-                                                     execution_policy);
-
-        if (!jit_error.Success())
-        {
-            const char *error_cstr = jit_error.AsCString();
-            if (error_cstr && error_cstr[0])
-                diagnostic_manager.PutCString(eDiagnosticSeverityError, error_cstr);
-            else
-                diagnostic_manager.PutCString(eDiagnosticSeverityError, "expression can't be interpreted or run");
-            return false;
-        }
+  // We use a shared pointer here so we can use the original parser - if it
+  // succeeds
+  // or the rewrite parser we might make if it fails.  But the parser_sp will
+  // never be empty.
+
+  ClangExpressionParser parser(exe_scope, *this, generate_debug_info);
+
+  unsigned num_errors = parser.Parse(diagnostic_manager);
+
+  // Check here for FixItHints.  If there are any try to apply the fixits and
+  // set the fixed text in m_fixed_text
+  // before returning an error.
+  if (num_errors) {
+    if (diagnostic_manager.HasFixIts()) {
+      if (parser.RewriteExpression(diagnostic_manager)) {
+        size_t fixed_start;
+        size_t fixed_end;
+        const std::string &fixed_expression =
+            diagnostic_manager.GetFixedExpression();
+        if (ExpressionSourceCode::GetOriginalBodyBounds(
+                fixed_expression, lang_type, fixed_start, fixed_end))
+          m_fixed_text =
+              fixed_expression.substr(fixed_start, fixed_end - fixed_start);
+      }
     }
 
-    if (exe_ctx.GetProcessPtr() && execution_policy == eExecutionPolicyTopLevel)
-    {
-        Error static_init_error = parser.RunStaticInitializers(m_execution_unit_sp, exe_ctx);
-
-        if (!static_init_error.Success())
-        {
-            const char *error_cstr = static_init_error.AsCString();
-            if (error_cstr && error_cstr[0])
-                diagnostic_manager.Printf(eDiagnosticSeverityError, "couldn't run static initializers: %s\n",
-                                          error_cstr);
-            else
-                diagnostic_manager.PutCString(eDiagnosticSeverityError, "couldn't run static initializers\n");
-            return false;
-        }
+    ResetDeclMap(); // We are being careful here in the case of breakpoint
+                    // conditions.
+
+    return false;
+  }
+
+  //////////////////////////////////////////////////////////////////////////////////////////
+  // Prepare the output of the parser for execution, evaluating it statically if
+  // possible
+  //
+
+  {
+    Error jit_error = parser.PrepareForExecution(
+        m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx,
+        m_can_interpret, execution_policy);
+
+    if (!jit_error.Success()) {
+      const char *error_cstr = jit_error.AsCString();
+      if (error_cstr && error_cstr[0])
+        diagnostic_manager.PutCString(eDiagnosticSeverityError, error_cstr);
+      else
+        diagnostic_manager.PutCString(eDiagnosticSeverityError,
+                                      "expression can't be interpreted or run");
+      return false;
+    }
+  }
+
+  if (exe_ctx.GetProcessPtr() && execution_policy == eExecutionPolicyTopLevel) {
+    Error static_init_error =
+        parser.RunStaticInitializers(m_execution_unit_sp, exe_ctx);
+
+    if (!static_init_error.Success()) {
+      const char *error_cstr = static_init_error.AsCString();
+      if (error_cstr && error_cstr[0])
+        diagnostic_manager.Printf(eDiagnosticSeverityError,
+                                  "couldn't run static initializers: %s\n",
+                                  error_cstr);
+      else
+        diagnostic_manager.PutCString(eDiagnosticSeverityError,
+                                      "couldn't run static initializers\n");
+      return false;
     }
+  }
 
-    if (m_execution_unit_sp)
-    {
-        bool register_execution_unit = false;
+  if (m_execution_unit_sp) {
+    bool register_execution_unit = false;
 
-        if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel)
-        {
-            register_execution_unit = true;
-        }
-        
-        // If there is more than one external function in the execution
-        // unit, it needs to keep living even if it's not top level, because
-        // the result could refer to that function.
-        
-        if (m_execution_unit_sp->GetJittedFunctions().size() > 1)
-        {
-            register_execution_unit = true;
-        }
+    if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
+      register_execution_unit = true;
+    }
 
-        if (register_execution_unit)
-        {
-            llvm::cast<PersistentExpressionState>(
-                exe_ctx.GetTargetPtr()->GetPersistentExpressionStateForLanguage(m_language))
-                ->RegisterExecutionUnit(m_execution_unit_sp);
-        }
+    // If there is more than one external function in the execution
+    // unit, it needs to keep living even if it's not top level, because
+    // the result could refer to that function.
+
+    if (m_execution_unit_sp->GetJittedFunctions().size() > 1) {
+      register_execution_unit = true;
     }
 
-    if (generate_debug_info)
-    {
-        lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
-
-        if (jit_module_sp)
-        {
-            ConstString const_func_name(FunctionName());
-            FileSpec jit_file;
-            jit_file.GetFilename() = const_func_name;
-            jit_module_sp->SetFileSpecAndObjectName (jit_file, ConstString());
-            m_jit_module_wp = jit_module_sp;
-            target->GetImages().Append(jit_module_sp);
-        }
+    if (register_execution_unit) {
+      llvm::cast<PersistentExpressionState>(
+          exe_ctx.GetTargetPtr()->GetPersistentExpressionStateForLanguage(
+              m_language))
+          ->RegisterExecutionUnit(m_execution_unit_sp);
+    }
+  }
+
+  if (generate_debug_info) {
+    lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
+
+    if (jit_module_sp) {
+      ConstString const_func_name(FunctionName());
+      FileSpec jit_file;
+      jit_file.GetFilename() = const_func_name;
+      jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
+      m_jit_module_wp = jit_module_sp;
+      target->GetImages().Append(jit_module_sp);
     }
+  }
 
-    ResetDeclMap(); // Make this go away since we don't need any of its state after parsing.  This also gets rid of any
-                    // ClangASTImporter::Minions.
+  ResetDeclMap(); // Make this go away since we don't need any of its state
+                  // after parsing.  This also gets rid of any
+                  // ClangASTImporter::Minions.
 
-    if (process && m_jit_start_addr != LLDB_INVALID_ADDRESS)
-        m_jit_process_wp = lldb::ProcessWP(process->shared_from_this());
-    return true;
+  if (process && m_jit_start_addr != LLDB_INVALID_ADDRESS)
+    m_jit_process_wp = lldb::ProcessWP(process->shared_from_this());
+  return true;
 }
 
-bool
-ClangUserExpression::AddArguments(ExecutionContext &exe_ctx, std::vector<lldb::addr_t> &args,
-                                  lldb::addr_t struct_address, DiagnosticManager &diagnostic_manager)
-{
-    lldb::addr_t object_ptr = LLDB_INVALID_ADDRESS;
-    lldb::addr_t cmd_ptr = LLDB_INVALID_ADDRESS;
-
-    if (m_needs_object_ptr)
-    {
-        lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP();
-        if (!frame_sp)
-            return true;
-        
-        ConstString object_name;
-
-        if (m_in_cplusplus_method)
-        {
-            object_name.SetCString("this");
-        }
-        else if (m_in_objectivec_method)
-        {
-            object_name.SetCString("self");
-        }
-        else
-        {
-            diagnostic_manager.PutCString(eDiagnosticSeverityError, "need object pointer but don't know the language");
-            return false;
-        }
+bool ClangUserExpression::AddArguments(ExecutionContext &exe_ctx,
+                                       std::vector<lldb::addr_t> &args,
+                                       lldb::addr_t struct_address,
+                                       DiagnosticManager &diagnostic_manager) {
+  lldb::addr_t object_ptr = LLDB_INVALID_ADDRESS;
+  lldb::addr_t cmd_ptr = LLDB_INVALID_ADDRESS;
+
+  if (m_needs_object_ptr) {
+    lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP();
+    if (!frame_sp)
+      return true;
+
+    ConstString object_name;
+
+    if (m_in_cplusplus_method) {
+      object_name.SetCString("this");
+    } else if (m_in_objectivec_method) {
+      object_name.SetCString("self");
+    } else {
+      diagnostic_manager.PutCString(
+          eDiagnosticSeverityError,
+          "need object pointer but don't know the language");
+      return false;
+    }
 
-        Error object_ptr_error;
+    Error object_ptr_error;
 
-        object_ptr = GetObjectPointer(frame_sp, object_name, object_ptr_error);
+    object_ptr = GetObjectPointer(frame_sp, object_name, object_ptr_error);
 
-        if (!object_ptr_error.Success())
-        {
-            exe_ctx.GetTargetRef().GetDebugger().GetAsyncOutputStream()->Printf("warning: `%s' is not accessible (subsituting 0)\n", object_name.AsCString());
-            object_ptr = 0;
-        }
+    if (!object_ptr_error.Success()) {
+      exe_ctx.GetTargetRef().GetDebugger().GetAsyncOutputStream()->Printf(
+          "warning: `%s' is not accessible (subsituting 0)\n",
+          object_name.AsCString());
+      object_ptr = 0;
+    }
 
-        if (m_in_objectivec_method)
-        {
-            ConstString cmd_name("_cmd");
+    if (m_in_objectivec_method) {
+      ConstString cmd_name("_cmd");
 
-            cmd_ptr = GetObjectPointer(frame_sp, cmd_name, object_ptr_error);
+      cmd_ptr = GetObjectPointer(frame_sp, cmd_name, object_ptr_error);
 
-            if (!object_ptr_error.Success())
-            {
-                diagnostic_manager.Printf(eDiagnosticSeverityWarning,
-                                          "couldn't get cmd pointer (substituting NULL): %s",
-                                          object_ptr_error.AsCString());
-                cmd_ptr = 0;
-            }
-        }
-        
-        args.push_back(object_ptr);
+      if (!object_ptr_error.Success()) {
+        diagnostic_manager.Printf(
+            eDiagnosticSeverityWarning,
+            "couldn't get cmd pointer (substituting NULL): %s",
+            object_ptr_error.AsCString());
+        cmd_ptr = 0;
+      }
+    }
 
-        if (m_in_objectivec_method)
-            args.push_back(cmd_ptr);
+    args.push_back(object_ptr);
 
-        args.push_back(struct_address);
-    }
-    else
-    {
-        args.push_back(struct_address);
-    }
-    return true;
+    if (m_in_objectivec_method)
+      args.push_back(cmd_ptr);
+
+    args.push_back(struct_address);
+  } else {
+    args.push_back(struct_address);
+  }
+  return true;
 }
 
-lldb::ExpressionVariableSP
-ClangUserExpression::GetResultAfterDematerialization(ExecutionContextScope *exe_scope)
-{
-    return m_result_delegate.GetVariable();
+lldb::ExpressionVariableSP ClangUserExpression::GetResultAfterDematerialization(
+    ExecutionContextScope *exe_scope) {
+  return m_result_delegate.GetVariable();
 }
 
-void
-ClangUserExpression::ClangUserExpressionHelper::ResetDeclMap(ExecutionContext &exe_ctx, Materializer::PersistentVariableDelegate &delegate, bool keep_result_in_memory)
-{
-    m_expr_decl_map_up.reset(new ClangExpressionDeclMap(keep_result_in_memory, &delegate, exe_ctx));
+void ClangUserExpression::ClangUserExpressionHelper::ResetDeclMap(
+    ExecutionContext &exe_ctx,
+    Materializer::PersistentVariableDelegate &delegate,
+    bool keep_result_in_memory) {
+  m_expr_decl_map_up.reset(
+      new ClangExpressionDeclMap(keep_result_in_memory, &delegate, exe_ctx));
 }
 
 clang::ASTConsumer *
-ClangUserExpression::ClangUserExpressionHelper::ASTTransformer(clang::ASTConsumer *passthrough)
-{
-    m_result_synthesizer_up.reset(new ASTResultSynthesizer(passthrough, m_top_level, m_target));
+ClangUserExpression::ClangUserExpressionHelper::ASTTransformer(
+    clang::ASTConsumer *passthrough) {
+  m_result_synthesizer_up.reset(
+      new ASTResultSynthesizer(passthrough, m_top_level, m_target));
 
-    return m_result_synthesizer_up.get();
+  return m_result_synthesizer_up.get();
 }
 
-void
-ClangUserExpression::ClangUserExpressionHelper::CommitPersistentDecls()
-{
-    if (m_result_synthesizer_up.get())
-    {
-        m_result_synthesizer_up->CommitPersistentDecls();
-    }
+void ClangUserExpression::ClangUserExpressionHelper::CommitPersistentDecls() {
+  if (m_result_synthesizer_up.get()) {
+    m_result_synthesizer_up->CommitPersistentDecls();
+  }
 }
 
-ClangUserExpression::ResultDelegate::ResultDelegate()
-{
-}
+ClangUserExpression::ResultDelegate::ResultDelegate() {}
 
-ConstString
-ClangUserExpression::ResultDelegate::GetName()
-{
-    return m_persistent_state->GetNextPersistentVariableName();
+ConstString ClangUserExpression::ResultDelegate::GetName() {
+  return m_persistent_state->GetNextPersistentVariableName();
 }
 
-void
-ClangUserExpression::ResultDelegate::DidDematerialize(lldb::ExpressionVariableSP &variable)
-{
-    m_variable = variable;
+void ClangUserExpression::ResultDelegate::DidDematerialize(
+    lldb::ExpressionVariableSP &variable) {
+  m_variable = variable;
 }
 
-void
-ClangUserExpression::ResultDelegate::RegisterPersistentState(PersistentExpressionState *persistent_state)
-{
-    m_persistent_state = persistent_state;
+void ClangUserExpression::ResultDelegate::RegisterPersistentState(
+    PersistentExpressionState *persistent_state) {
+  m_persistent_state = persistent_state;
 }
 
-lldb::ExpressionVariableSP &
-ClangUserExpression::ResultDelegate::GetVariable()
-{
-    return m_variable;
+lldb::ExpressionVariableSP &ClangUserExpression::ResultDelegate::GetVariable() {
+  return m_variable;
 }
-