Revert "Use an artifical namespace so that member vars do not hide local vars."

[sivachandra]

Summary

This reverts commit 8af14b5f9af68c31ac80945e5b5d56f0a14b38e4.
Reverting as it breaks a few tests on Mac.

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,
-                               const bool ignore_using_decls) override;
+    DeclContextFindDeclByName (void *opaque_decl_ctx, ConstString name) 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, const bool ignore_using_decls);
+    FindDeclByName (ConstString name);
 
     //----------------------------------------------------------------------
     /// 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,
-                               const bool ignore_imported_decls);
+    DeclContextFindDeclByName (void *opaque_decl_ctx, ConstString name);
 
     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"))
-            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;
 
-        bool local_var_lookup = !namespace_decl ||
-                                (namespace_decl.GetName() == ConstString(g_lldb_local_vars_namespace_cstr));
-        if (frame && local_var_lookup)
+        if (frame && !namespace_decl)
         {
             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. 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());
+                // Search for declarations matching the name
+                std::vector<CompilerDecl> found_decls = compiler_decl_context.FindDeclByName(name);
                 
                 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,
-                                           const bool ignore_using_decls)
+ClangASTContext::DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name)
 {
     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, const bool ignore_using_decls)
+CompilerDeclContext::FindDeclByName (ConstString name)
 {
     if (IsValid())
-        return m_type_system->DeclContextFindDeclByName(
-            m_opaque_decl_ctx, name, ignore_using_decls);
+        return m_type_system->DeclContextFindDeclByName(m_opaque_decl_ctx, name);
     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,
-                                       bool ignore_imported_decls)
+TypeSystem::DeclContextFindDeclByName (void *opaque_decl_ctx, ConstString name)
 {
     return std::vector<CompilerDecl>();
 }
 
 
 #pragma mark TypeSystemMap
 
 TypeSystemMap::TypeSystemMap() :