Take 2: Use an artifical namespace so that member vars do not hide local vars.

[sivachandra]

Summary

This relands r259810 with fix for failures on Mac.

[sivachandra]

source/Expression/ExpressionSourceCode.cpp

188

This line is the only one difference between the previous version and this. An additional check for a var with name ".block_descriptor" has been added.

[tfiala]

I'm going to try this out now

[tfiala]

This tested cleanly, no failures on OS X. Lgtm.

-Todd

[sivachandra]

Thanks a lot Todd. I will put this in tomorrow morning just to be on the safer side.

[tfiala]

In D16900#344702, @sivachandra wrote:

Thanks a lot Todd. I will put this in tomorrow morning just to be on the safer side.

My pleasure, Siva!

include/lldb/Symbol/ClangASTContext.h

public:
     //------------------------------------------------------------------
     // Namespace Declarations
     //------------------------------------------------------------------
 
     clang::NamespaceDecl *
     GetUniqueNamespaceDeclaration (const char *name,
                                    clang::DeclContext *decl_ctx);
 
+    static clang::NamespaceDecl *
+    GetUniqueNamespaceDeclaration (clang::ASTContext *ast,
+                                   const char *name,
+                                   clang::DeclContext *decl_ctx);
+
     //------------------------------------------------------------------
     // Function Types
     //------------------------------------------------------------------
 
     clang::FunctionDecl *
     CreateFunctionDeclaration (clang::DeclContext *decl_ctx,
                                const char *name,
                                const CompilerType &function_Type,
public:
     CompilerType
     DeclGetFunctionArgumentType (void *opaque_decl, size_t arg_idx) override;
 
     //----------------------------------------------------------------------
     // CompilerDeclContext override functions
     //----------------------------------------------------------------------
     
     std::vector<CompilerDecl>
-    DeclContextFindDeclByName (void *opaque_decl_ctx, ConstString name) override;
+    DeclContextFindDeclByName (void *opaque_decl_ctx,
+                               ConstString name,
+                               const bool ignore_using_decls) override;
 
     bool
     DeclContextIsStructUnionOrClass (void *opaque_decl_ctx) override;
 
     ConstString
     DeclContextGetName (void *opaque_decl_ctx) override;
 
     ConstString

include/lldb/Symbol/CompilerDeclContext.h

public:
     {
         return m_type_system != nullptr && m_opaque_decl_ctx != nullptr;
     }
 
     bool
     IsClang () const;
 
     std::vector<CompilerDecl>
-    FindDeclByName (ConstString name);
+    FindDeclByName (ConstString name, const bool ignore_using_decls);
 
     //----------------------------------------------------------------------
     /// Checks if this decl context represents a method of a class.
     ///
     /// @param[out] language_ptr
     ///     If non NULL and \b true is returned from this function,
     ///     this will indicate if the language that respresents the method.
     ///

include/lldb/Symbol/TypeSystem.h

public:
     virtual CompilerType
     DeclGetFunctionArgumentType (void *opaque_decl, size_t arg_idx);
 
     //----------------------------------------------------------------------
     // CompilerDeclContext functions
     //----------------------------------------------------------------------
     
     virtual std::vector<CompilerDecl>
-    DeclContextFindDeclByName (void *opaque_decl_ctx, ConstString name);
+    DeclContextFindDeclByName (void *opaque_decl_ctx,
+                               ConstString name,
+                               const bool ignore_imported_decls);
 
     virtual bool
     DeclContextIsStructUnionOrClass (void *opaque_decl_ctx) = 0;
 
     virtual ConstString
     DeclContextGetName (void *opaque_decl_ctx) = 0;
 
     virtual ConstString

packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES = main.cpp
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/TestMembersAndLocalsWithSameName.py

+import lldb
+from lldbsuite.test.lldbtest import *
+import lldbsuite.test.lldbutil as lldbutil
+
+class TestMembersAndLocalsWithSameName(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_when_stopped_in_method(self):
+        self._load_exe()
+
+        # Set breakpoints
+        bp1 = self.target.BreakpointCreateBySourceRegex("Break 1", self.src_file_spec)
+        self.assertTrue(bp1.IsValid() and bp1.GetNumLocations() >= 1, VALID_BREAKPOINT)
+        bp2 = self.target.BreakpointCreateBySourceRegex("Break 2", self.src_file_spec)
+        self.assertTrue(bp2.IsValid() and bp2.GetNumLocations() >= 1, VALID_BREAKPOINT)
+        bp3 = self.target.BreakpointCreateBySourceRegex("Break 3", self.src_file_spec)
+        self.assertTrue(bp3.IsValid() and bp3.GetNumLocations() >= 1, VALID_BREAKPOINT)
+        bp4 = self.target.BreakpointCreateBySourceRegex("Break 4", self.src_file_spec)
+        self.assertTrue(bp4.IsValid() and bp4.GetNumLocations() >= 1, VALID_BREAKPOINT)
+
+        # Launch the process
+        self.process = self.target.LaunchSimple(None, None, self.get_process_working_directory())
+        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+
+        self.assertTrue(self.process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+
+        self._test_globals()
+
+        self.process.Continue()
+        self.assertTrue(self.process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(self.process, lldb.eStopReasonBreakpoint)
+        self.assertTrue(thread.IsValid())
+        frame = thread.GetSelectedFrame()
+        self.assertTrue(frame.IsValid())
+
+        val = frame.EvaluateExpression("a");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 12345)
+
+        val = frame.EvaluateExpression("b");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 54321)
+
+        val = frame.EvaluateExpression("c");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 34567)
+
+        self.process.Continue()
+        self.assertTrue(self.process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(self.process, lldb.eStopReasonBreakpoint)
+        self.assertTrue(thread.IsValid())
+        frame = thread.GetSelectedFrame()
+        self.assertTrue(frame.IsValid())
+
+        val = frame.EvaluateExpression("a");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 10001)
+
+        val = frame.EvaluateExpression("b");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 10002)
+
+        val = frame.EvaluateExpression("c");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 10003)
+
+        self.process.Continue()
+        self.assertTrue(self.process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(self.process, lldb.eStopReasonBreakpoint)
+        self.assertTrue(thread.IsValid())
+        frame = thread.GetSelectedFrame()
+        self.assertTrue(frame.IsValid())
+
+        val = frame.EvaluateExpression("a");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 1)
+
+        val = frame.EvaluateExpression("b");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 2)
+
+        val = frame.EvaluateExpression("c");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 778899)
+
+    def test_when_stopped_in_function(self):
+        self._load_exe()
+
+        # Set breakpoints
+        bp1 = self.target.BreakpointCreateBySourceRegex("Break 1", self.src_file_spec)
+        self.assertTrue(bp1.IsValid() and bp1.GetNumLocations() >= 1, VALID_BREAKPOINT)
+        bp5 = self.target.BreakpointCreateBySourceRegex("Break 5", self.src_file_spec)
+        self.assertTrue(bp5.IsValid() and bp5.GetNumLocations() >= 1, VALID_BREAKPOINT)
+        bp6 = self.target.BreakpointCreateBySourceRegex("Break 6", self.src_file_spec)
+        self.assertTrue(bp6.IsValid() and bp6.GetNumLocations() >= 1, VALID_BREAKPOINT)
+        bp7 = self.target.BreakpointCreateBySourceRegex("Break 7", self.src_file_spec)
+        self.assertTrue(bp7.IsValid() and bp7.GetNumLocations() >= 1, VALID_BREAKPOINT)
+
+        # Launch the process
+        self.process = self.target.LaunchSimple(None, None, self.get_process_working_directory())
+        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+
+        self.assertTrue(self.process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+
+        self._test_globals()
+
+        self.process.Continue()
+        self.assertTrue(self.process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(self.process, lldb.eStopReasonBreakpoint)
+        self.assertTrue(thread.IsValid())
+        frame = thread.GetSelectedFrame()
+        self.assertTrue(frame.IsValid())
+
+        val = frame.EvaluateExpression("a");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 12345)
+
+        val = frame.EvaluateExpression("b");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 54321)
+
+        val = frame.EvaluateExpression("c");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 34567)
+
+        self.process.Continue()
+        self.assertTrue(self.process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(self.process, lldb.eStopReasonBreakpoint)
+        self.assertTrue(thread.IsValid())
+        frame = thread.GetSelectedFrame()
+        self.assertTrue(frame.IsValid())
+
+        val = frame.EvaluateExpression("a");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 10001)
+
+        val = frame.EvaluateExpression("b");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 10002)
+
+        val = frame.EvaluateExpression("c");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 10003)
+
+        self.process.Continue()
+        self.assertTrue(self.process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(self.process, lldb.eStopReasonBreakpoint)
+        self.assertTrue(thread.IsValid())
+        frame = thread.GetSelectedFrame()
+        self.assertTrue(frame.IsValid())
+
+        val = frame.EvaluateExpression("a");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 1)
+
+        val = frame.EvaluateExpression("b");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 2)
+
+        val = frame.EvaluateExpression("c");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 778899)
+
+    def _load_exe(self):
+        self.build()
+
+        cwd = os.getcwd()
+
+        src_file = os.path.join(cwd, "main.cpp")
+        self.src_file_spec = lldb.SBFileSpec(src_file)
+        self.assertTrue(self.src_file_spec.IsValid(), "breakpoint file")
+
+        # Get the path of the executable
+        exe_path  = os.path.join(cwd, 'a.out')
+
+        # Load the executable
+        self.target = self.dbg.CreateTarget(exe_path)
+        self.assertTrue(self.target.IsValid(), VALID_TARGET)
+
+    def _test_globals(self):
+        thread = lldbutil.get_stopped_thread(self.process, lldb.eStopReasonBreakpoint)
+        self.assertTrue(thread.IsValid())
+        frame = thread.GetSelectedFrame()
+        self.assertTrue(frame.IsValid())
+
+        val = frame.EvaluateExpression("a");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 112233)
+
+        val = frame.EvaluateExpression("b");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 445566)
+
+        val = frame.EvaluateExpression("c");
+        self.assertTrue(val.IsValid())
+        self.assertEqual(val.GetValueAsUnsigned(), 778899)

packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/main.cpp

+namespace NN
+{
+  int a = 778899;
+  int b = 665544;
+  int c = 445566;
+}
+
+class A
+{
+public:
+  A();
+  int Method(int a, int b);
+
+private:
+  int a, b;
+};
+
+A::A() : a(10), b(100) { }
+
+int a = 112233;
+int b = 445566;
+int c = 778899;
+
+int
+A::Method(int a, int b)
+{
+    {
+        int a = 12345;
+        int b = 54321;
+        int c = 34567;
+        this->a = a + b + this->b; // Break 2
+    }
+
+    {
+        using namespace NN;
+        int a = 10001;
+        int b = 10002;
+        int c = 10003;
+        this->a = a + b + this->b; // Break 3
+    }
+
+    return this->a + this->b + a + b; // Break 4
+}
+
+int
+Function(int a, int b)
+{
+    int A;
+
+    {
+        int a = 12345;
+        int b = 54321;
+        int c = 34567;
+        A = a + b + c; // Break 5
+    }
+
+    {
+        using namespace NN;
+        int a = 10001;
+        int b = 10002;
+        int c = 10003;
+        A = a + b + c; // Break 6
+    }
+
+    return A + a + b; // Break 7
+}
+
+int
+main()
+{
+    A obj;
+    return obj.Method(1, 2) + Function(1, 2); // Break 1
+}

source/Expression/ExpressionSourceCode.cpp

 
 #include "lldb/Core/StreamString.h"
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/TypeSystem.h"
+#include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Language.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb_private;
 
 const char *
 ExpressionSourceCode::g_expression_prefix = R"(
for (size_t i = 0; i < dm->GetNumMacroEntries(); i++)
                 break;
             default:
                 // This is an unknown/invalid entry. Ignore.
                 break;
         }
     }
 }
 
+static void
+AddLocalVariableDecls(const lldb::VariableListSP &var_list_sp, StreamString &stream)
+{
+    for (size_t i = 0; i < var_list_sp->GetSize(); i++)
+    {
+        lldb::VariableSP var_sp = var_list_sp->GetVariableAtIndex(i);
+
+        ConstString var_name = var_sp->GetName();
+        if (var_name == ConstString("this") || var_name == ConstString(".block_descriptor"))
+            continue;
+
+        stream.Printf("using $__lldb_local_vars::%s;\n", var_name.AsCString());
+    }
+}
+
 bool ExpressionSourceCode::GetText (std::string &text, lldb::LanguageType wrapping_language, bool const_object, bool static_method, ExecutionContext &exe_ctx) const
 {
     const char *target_specific_defines = "typedef signed char BOOL;\n";
     std::string module_macros;
     
     if (Target *target = exe_ctx.GetTargetPtr())
     {
         if (target->GetArchitecture().GetMachine() == llvm::Triple::aarch64)
if (Target *target = exe_ctx.GetTargetPtr())
                 module_macros.append("\n");
                 return false;
             });
         }
 
     }
 
     StreamString debug_macros_stream;
+    StreamString lldb_local_var_decls;
     if (StackFrame *frame = exe_ctx.GetFramePtr())
     {
         const SymbolContext &sc = frame->GetSymbolContext(
            lldb:: eSymbolContextCompUnit | lldb::eSymbolContextLineEntry);
 
         if (sc.comp_unit && sc.line_entry.IsValid())
         {
             DebugMacros *dm = sc.comp_unit->GetDebugMacros();
             if (dm)
             {
                 AddMacroState state(sc.line_entry.file, sc.line_entry.line);
                 AddMacros(dm, sc.comp_unit, state, debug_macros_stream);
             }
         }
+
+        ConstString object_name;
+        if (Language::LanguageIsCPlusPlus(frame->GetLanguage()))
+        {
+            lldb::VariableListSP var_list_sp = frame->GetInScopeVariableList(false);
+            AddLocalVariableDecls(var_list_sp, lldb_local_var_decls);
+        }
     }
-    
     if (m_wrap)
     {
         switch (wrapping_language) 
         {
         default:
             return false;
         case lldb::eLanguageTypeC:
         case lldb::eLanguageTypeC_plus_plus:
if (m_wrap)
         switch (wrapping_language) 
         {
         default:
             break;
         case lldb::eLanguageTypeC:
             wrap_stream.Printf("void                           \n"
                                "%s(void *$__lldb_arg)          \n"
                                "{                              \n"
-                               "    %s;                        \n" 
+                               "    %s;                        \n"
+                               "    %s;                        \n" 
                                "}                              \n",
                                m_name.c_str(),
+                               lldb_local_var_decls.GetData(),
                                m_body.c_str());
             break;
         case lldb::eLanguageTypeC_plus_plus:
             wrap_stream.Printf("void                                   \n"
                                "$__lldb_class::%s(void *$__lldb_arg) %s\n"
                                "{                                      \n"
-                               "    %s;                                \n" 
+                               "    %s;                                \n"
+                               "    %s;                                \n" 
                                "}                                      \n",
                                m_name.c_str(),
                                (const_object ? "const" : ""),
+                               lldb_local_var_decls.GetData(),
                                m_body.c_str());
             break;
         case lldb::eLanguageTypeObjC:
             if (static_method)
             {
                 wrap_stream.Printf("@interface $__lldb_objc_class ($__lldb_category)        \n"
                                    "+(void)%s:(void *)$__lldb_arg;                          \n"
                                    "@end                                                    \n"
if (m_wrap)
         }
         
         text = wrap_stream.GetString();
     }
     else
     {
         text.append(m_body);
     }
-    
     return true;
 }

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h

private:
     ///
     /// @param[in] type
     ///     The type for *this.
     //------------------------------------------------------------------
     void
     AddThisType(NameSearchContext &context,
                 TypeFromUser &type,
                 unsigned int current_id);
+
+    ClangASTContext *
+    GetClangASTContext();
 };
     
 } // namespace lldb_private
 
 #endif // liblldb_ClangExpressionDeclMap_h_

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

 #include "lldb/Target/Thread.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace clang;
 
+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),
if (vars.GetSize())
         {
             return vars.GetVariableAtIndex(0);
         }
     }
 
     return VariableSP();
 }
 
+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;
+
+    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());
+}
+
 // Interface for ClangASTSource
 
 void
 ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context)
 {
     assert (m_ast_context);
 
     ClangASTMetrics::RegisterVisibleQuery();
if (log)
         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(), (void*)context.m_decl_context);
+            FindExternalVisibleDecls(context, lldb::ModuleSP(), compiler_decl_ctx, current_id);
+            return;
+        }
+
         ClangASTImporter::NamespaceMapSP namespace_map = m_ast_importer_sp->GetNamespaceMap(namespace_context);
 
         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)
if (name_unique_cstr[0] == '$' && !namespace_decl)
                         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);
+                    }
+                }
+            }
+
+            return;
+        }
+
         // any other $__lldb names should be weeded out now
         if (!::strncmp(name_unique_cstr, "$__lldb", sizeof("$__lldb") - 1))
             return;
 
         do
         {
             if (!target)
                 break;
if (name_unique_cstr[0] == '$' && !namespace_decl)
             }
         }
     }
     else
     {
         ValueObjectSP valobj;
         VariableSP var;
 
-        if (frame && !namespace_decl)
+        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
+                // 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
-                std::vector<CompilerDecl> found_decls = compiler_decl_context.FindDeclByName(name);
+                // 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)
                 {
                     var = decl.GetAsVariable();
                     if (var)
                     {
                         variable_found = true;

source/Symbol/ClangASTContext.cpp

else
         }
     }
 #ifdef LLDB_CONFIGURATION_DEBUG
     VerifyDecl(namespace_decl);
 #endif
     return namespace_decl;
 }
 
+NamespaceDecl *
+ClangASTContext::GetUniqueNamespaceDeclaration (clang::ASTContext *ast,
+                                                const char *name,
+                                                clang::DeclContext *decl_ctx)
+{
+    ClangASTContext *ast_ctx = ClangASTContext::GetASTContext(ast);
+    if (ast_ctx == nullptr)
+        return nullptr;
+
+    return ast_ctx->GetUniqueNamespaceDeclaration(name, decl_ctx);
+}
 
 clang::BlockDecl *
 ClangASTContext::CreateBlockDeclaration (clang::DeclContext *ctx)
 {
     if (ctx != nullptr)
     {
         clang::BlockDecl *decl = clang::BlockDecl::Create(*getASTContext(), ctx, clang::SourceLocation());
         ctx->addDecl(decl);
ClangASTContext::DeclGetFunctionArgumentType (void *opaque_decl, size_t idx)
     return CompilerType();
 }
 
 //----------------------------------------------------------------------
 // CompilerDeclContext functions
 //----------------------------------------------------------------------
 
 std::vector<CompilerDecl>
-ClangASTContext::DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name)
+ClangASTContext::DeclContextFindDeclByName(void *opaque_decl_ctx,
+                                           ConstString name,
+                                           const bool ignore_using_decls)
 {
     std::vector<CompilerDecl> found_decls;
     if (opaque_decl_ctx)
     {
         DeclContext *root_decl_ctx = (DeclContext *)opaque_decl_ctx;
         std::set<DeclContext *> searched;
         std::multimap<DeclContext *, DeclContext *> search_queue;
         SymbolFile *symbol_file = GetSymbolFile();
 
         for (clang::DeclContext *decl_context = root_decl_ctx; decl_context != nullptr && found_decls.empty(); decl_context = decl_context->getParent())
         {
             search_queue.insert(std::make_pair(decl_context, decl_context));
 
             for (auto it = search_queue.find(decl_context); it != search_queue.end(); it++)
             {
                 if (!searched.insert(it->second).second)
                     continue;
                 symbol_file->ParseDeclsForContext(CompilerDeclContext(this, it->second));
 
                 for (clang::Decl *child : it->second->decls())
                 {
                     if (clang::UsingDirectiveDecl *ud = llvm::dyn_cast<clang::UsingDirectiveDecl>(child))
                     {
+                        if (ignore_using_decls)
+                            continue;
                         clang::DeclContext *from = ud->getCommonAncestor();
                         if (searched.find(ud->getNominatedNamespace()) == searched.end())
                             search_queue.insert(std::make_pair(from, ud->getNominatedNamespace()));
                     }
                     else if (clang::UsingDecl *ud = llvm::dyn_cast<clang::UsingDecl>(child))
                     {
+                        if (ignore_using_decls)
+                            continue;
                         for (clang::UsingShadowDecl *usd : ud->shadows())
                         {
                             clang::Decl *target = usd->getTargetDecl();
                             if (clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(target))
                             {
                                 IdentifierInfo *ii = nd->getIdentifier();
                                 if (ii != nullptr && ii->getName().equals(name.AsCString(nullptr)))
                                     found_decls.push_back(CompilerDecl(this, nd));

source/Symbol/CompilerDeclContext.cpp

 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include <vector>
 
 using namespace lldb_private;
 
 std::vector<CompilerDecl>
-CompilerDeclContext::FindDeclByName (ConstString name)
+CompilerDeclContext::FindDeclByName (ConstString name, const bool ignore_using_decls)
 {
     if (IsValid())
-        return m_type_system->DeclContextFindDeclByName(m_opaque_decl_ctx, name);
+        return m_type_system->DeclContextFindDeclByName(
+            m_opaque_decl_ctx, name, ignore_using_decls);
     else
         return std::vector<CompilerDecl>();
 }
 
 bool
 CompilerDeclContext::IsClang () const
 {
     return IsValid() && m_type_system->getKind() == TypeSystem::eKindClang;

source/Symbol/TypeSystem.cpp

 CompilerType
 TypeSystem::DeclGetFunctionArgumentType (void *opaque_decl, size_t arg_idx)
 {
     return CompilerType();
 }
 
 
 std::vector<CompilerDecl>
-TypeSystem::DeclContextFindDeclByName (void *opaque_decl_ctx, ConstString name)
+TypeSystem::DeclContextFindDeclByName (void *opaque_decl_ctx,
+                                       ConstString name,
+                                       bool ignore_imported_decls)
 {
     return std::vector<CompilerDecl>();
 }
 
 
 #pragma mark TypeSystemMap
 
 TypeSystemMap::TypeSystemMap() :