Add using directives to the clang::DeclContext and fix decls for variables inside namespaces

[paulherman]

Summary

Supports the parsing of the "using namespace XXX" and "using XXX::XXX" directives. Added ambiguity errors when it two decls with the same name are encountered (see comments in TestCppNsImport). Fixes using directives being duplicated for anonymous namespaces. Fixes GetDeclForUID for specification DIEs.

[clayborg]

If you can explain the need for ParseDeclsForContext() as mentioned in the inlined comment that would help me understand this change better.

Also, Sean suggested that we might be able to fix all of this in another way that might make it easier on everyone: don't do any of the decl context searches manually like we are, but just add the using directives to the expression source code. When we make an expression we make a $_lldb_expr function and we put our expression inside of it. So if I run to "main" and run:

(lldb) expr argc

We generate the code:

void                           
$__lldb_expr(void *$__lldb_arg)          
{                              
argc;                            
}

Now, if we grabbed the using directives, we could translate them into source and place them inside the function lexical block:

void                           
$__lldb_expr(void *$__lldb_arg)          
{                              
using namespace foo;
using namespace bar;
argc;                            
}

Then we might not need to make as any modifications to the name lookups to do this manually. Thoughts?

source/Symbol/ClangASTContext.cpp

8877

Can you explain why you need to call ParseDeclsForContext() here? I would like to always avoid parsing everything within a decl context if possible only allow targeted searches (find "b" in namespace "a", not parse everything in namespace "a").

[paulherman]

The need for ParseDeclsInContext is to get a list of namespaces that are contained within a using-directive. This does not actually parse anything but DW_TAG_imported_namespace and DW_TAG_imported_decl. The actual contents of the namespace are parsed only when the search reaches it.

About having the using-directives in the source that is passed to clang, I don't think that will work since there is a comment in ClangASTSource::FindExternalDeclsByName:

// Using directives found in this context.
// Tell Sema we didn't find any or we'll end up getting asked a *lot*.
case DeclarationName::CXXUsingDirective:
  SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
  return false;

[clayborg]

Thanks for the explanation and it makes sense. Looks good.

[paulherman]

Add using directives to the clang::DeclContext and fix decls for variables inside namespaces

Rebased the patch.

include/lldb/Symbol/SymbolFile.h

public:
     virtual bool            ParseCompileUnitLineTable (const SymbolContext& sc) = 0;
     virtual bool            ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files) = 0;
     virtual bool            ParseImportedModules (const SymbolContext &sc, std::vector<ConstString> &imported_modules) = 0;
     virtual size_t          ParseFunctionBlocks (const SymbolContext& sc) = 0;
     virtual size_t          ParseTypes (const SymbolContext& sc) = 0;
     virtual size_t          ParseVariablesForContext (const SymbolContext& sc) = 0;
     virtual Type*           ResolveTypeUID (lldb::user_id_t type_uid) = 0;
     virtual bool            CompleteType (CompilerType &clang_type) = 0;
+    virtual void            ParseDeclsForContext (CompilerDeclContext decl_ctx) {}
     virtual CompilerDecl    GetDeclForUID (lldb::user_id_t uid) { return CompilerDecl(); }
     virtual CompilerDeclContext GetDeclContextForUID (lldb::user_id_t uid) { return CompilerDeclContext(); }
     virtual CompilerDeclContext GetDeclContextContainingUID (lldb::user_id_t uid) { return CompilerDeclContext(); }
     virtual uint32_t        ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc) = 0;
     virtual uint32_t        ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list);
     virtual uint32_t        FindGlobalVariables (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, VariableList& variables);
     virtual uint32_t        FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables);
     virtual uint32_t        FindFunctions (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, SymbolContextList& sc_list);

source/Expression/ClangExpressionDeclMap.cpp

if (name_unique_cstr[0] == '$' && !namespace_decl)
                 AddOneRegister(context, reg_info, current_id);
             }
         }
     }
     else
     {
         ValueObjectSP valobj;
         VariableSP var;
-        Error err;
 
         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
                 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);
+                
+                bool variable_found = false;
                 for (CompilerDecl decl : found_decls)
                 {
                     var = decl.GetAsVariable();
                     if (var)
                     {
+                        variable_found = true;
                         valobj = ValueObjectVariable::Create(frame, var);
                         AddOneVariable(context, var, valobj, current_id);
                         context.m_found.variable = true;
-                        return;
                     }
                 }
+                if (variable_found)
+                    return;
             }
         }
         if (target)
         {
             var = FindGlobalVariable (*target,
                                       module_sp,
                                       name,
                                       &namespace_decl,

source/Plugins/SymbolFile/DWARF/DWARFASTParser.h

public:
     virtual lldb_private::CompilerDecl
     GetDeclForUIDFromDWARF (const DWARFDIE &die) = 0;
 
     virtual lldb_private::CompilerDeclContext
     GetDeclContextForUIDFromDWARF (const DWARFDIE &die) = 0;
 
     virtual lldb_private::CompilerDeclContext
     GetDeclContextContainingUIDFromDWARF (const DWARFDIE &die) = 0;
+
+    virtual std::vector<DWARFDIE>
+    GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) = 0;
 };
 
 #endif  // SymbolFileDWARF_DWARFASTParser_h_

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

public:
     virtual bool
     CompleteTypeFromDWARF (const DWARFDIE &die,
                            lldb_private::Type *type,
                            lldb_private::CompilerType &clang_type) override;
 
     virtual lldb_private::CompilerDecl
     GetDeclForUIDFromDWARF (const DWARFDIE &die) override;
 
+    virtual std::vector<DWARFDIE>
+    GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) override;
+
     virtual lldb_private::CompilerDeclContext
     GetDeclContextForUIDFromDWARF (const DWARFDIE &die) override;
 
     virtual lldb_private::CompilerDeclContext
     GetDeclContextContainingUIDFromDWARF (const DWARFDIE &die) override;
 
     bool
     LayoutRecordType(const clang::RecordDecl *record_decl,
protected:
     LinkDeclContextToDIE (clang::DeclContext *decl_ctx,
                           const DWARFDIE &die);
 
     void
     LinkDeclToDIE (clang::Decl *decl, const DWARFDIE &die);
 
     typedef llvm::SmallPtrSet<const DWARFDebugInfoEntry *, 4> DIEPointerSet;
     typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *> DIEToDeclContextMap;
-    typedef llvm::DenseMap<const clang::DeclContext *, DIEPointerSet> DeclContextToDIEMap;
+    //typedef llvm::DenseMap<const clang::DeclContext *, DIEPointerSet> DeclContextToDIEMap;
+    typedef std::multimap<const clang::DeclContext *, const DWARFDIE> DeclContextToDIEMap;
     typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *> DIEToDeclMap;
     typedef llvm::DenseMap<const clang::Decl *, DIEPointerSet> DeclToDIEMap;
 
     lldb_private::ClangASTContext &m_ast;
     DIEToDeclMap m_die_to_decl;
     DeclToDIEMap m_decl_to_die;
     DIEToDeclContextMap m_die_to_decl_ctx;
     DeclContextToDIEMap m_decl_ctx_to_die;
     RecordDeclToLayoutMap m_record_decl_to_layout_map;
 };
 
 #endif  // SymbolFileDWARF_DWARFASTParserClang_h_

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/Language.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 
+#include <map>
+#include <vector>
+
 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
 
 #ifdef ENABLE_DEBUG_PRINTF
 #include <stdio.h>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif
switch (tag)
         default:
             assert(false && "not a forward clang type decl!");
             break;
     }
 
     return false;
 }
 
+std::vector<DWARFDIE>
+DWARFASTParserClang::GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) 
+{
+    std::vector<DWARFDIE> result;
+    for (auto it = m_decl_ctx_to_die.find((clang::DeclContext *)decl_context.GetOpaqueDeclContext()); it != m_decl_ctx_to_die.end(); it++)
+        result.push_back(it->second);
+    return result;
+}
+
 CompilerDecl
 DWARFASTParserClang::GetDeclForUIDFromDWARF (const DWARFDIE &die)
 {
     clang::Decl *clang_decl = GetClangDeclForDIE(die);
     if (clang_decl != nullptr)
         return CompilerDecl(&m_ast, clang_decl);
     return CompilerDecl();
 }

 }
 
 clang::Decl *
 DWARFASTParserClang::GetClangDeclForDIE (const DWARFDIE &die)
 {
     if (!die)
         return nullptr;
 
+    if (die.GetReferencedDIE(DW_AT_specification))
+        return GetClangDeclForDIE(die.GetReferencedDIE(DW_AT_specification));
+
     clang::Decl *decl = m_die_to_decl[die.GetDIE()];
     if (decl != nullptr)
         return decl;
 
     switch (die.Tag())
     {
         case DW_TAG_variable:
         case DW_TAG_constant:
switch (die.Tag())
             lldb::user_id_t imported_uid = die.GetAttributeValueAsReference(DW_AT_import, DW_INVALID_OFFSET);
 
             if (dwarf->UserIDMatches(imported_uid))
             {
                 CompilerDeclContext imported_decl = dwarf->GetDeclContextForUID(imported_uid);
                 if (imported_decl)
                 {
                     clang::DeclContext *decl_context = ClangASTContext::DeclContextGetAsDeclContext(dwarf->GetDeclContextContainingUID(die.GetID()));
-                    if (clang::NamespaceDecl *clang_imported_decl = llvm::dyn_cast<clang::NamespaceDecl>((clang::DeclContext *)imported_decl.GetOpaqueDeclContext()))
-                        decl = m_ast.CreateUsingDirectiveDeclaration(decl_context, clang_imported_decl);
+                    if (clang::NamespaceDecl *ns_decl = ClangASTContext::DeclContextGetAsNamespaceDecl(imported_decl))
+                        decl = m_ast.CreateUsingDirectiveDeclaration(decl_context, ns_decl);
                 }
             }
             break;
         }
         default:
             break;
     }
 
DWARFASTParserClang::GetCachedClangDeclContextForDIE (const DWARFDIE &die)
     return nullptr;
 }
 
 void
 DWARFASTParserClang::LinkDeclContextToDIE (clang::DeclContext *decl_ctx, const DWARFDIE &die)
 {
     m_die_to_decl_ctx[die.GetDIE()] = decl_ctx;
     // There can be many DIEs for a single decl context
-    m_decl_ctx_to_die[decl_ctx].insert(die.GetDIE());
+    //m_decl_ctx_to_die[decl_ctx].insert(die.GetDIE());
+    m_decl_ctx_to_die.insert(std::make_pair(decl_ctx, die));
 }
 
 bool
 DWARFASTParserClang::CopyUniqueClassMethodTypes (const DWARFDIE &src_class_die,
                                                  const DWARFDIE &dst_class_die,
                                                  lldb_private::Type *class_type,
                                                  DWARFDIECollection &failures)
 {

source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.h

 //===-- DWARFASTParserGo.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFASTParserGo_h_
 #define SymbolFileDWARF_DWARFASTParserGo_h_
 
 #include "DWARFDefines.h"
 #include "DWARFASTParser.h"
+#include "DWARFDIE.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/GoASTContext.h"
 
public:
     }
 
     virtual lldb_private::CompilerDecl
     GetDeclForUIDFromDWARF (const DWARFDIE &die) override
     {
         return lldb_private::CompilerDecl();
     }
 
+    virtual std::vector<DWARFDIE>
+    GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) override
+    {
+        return std::vector<DWARFDIE>();
+    }
+
   private:
     size_t ParseChildParameters(const lldb_private::SymbolContext &sc, const DWARFDIE &parent_die, bool &is_variadic,
                                 std::vector<lldb_private::CompilerType> &function_param_types);
     void ParseChildArrayInfo(const lldb_private::SymbolContext &sc, const DWARFDIE &parent_die, int64_t &first_index,
                              std::vector<uint64_t> &element_orders, uint32_t &byte_stride, uint32_t &bit_stride);
 
     size_t ParseChildMembers(const lldb_private::SymbolContext &sc, const DWARFDIE &die,
                              lldb_private::CompilerType &class_clang_type);
 
     lldb_private::GoASTContext &m_ast;
 };
 
 #endif // SymbolFileDWARF_DWARFASTParserGo_h_

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
     GetDeclForUID (lldb::user_id_t uid) override;
 
     lldb_private::CompilerDeclContext
     GetDeclContextForUID (lldb::user_id_t uid) override;
 
     lldb_private::CompilerDeclContext
     GetDeclContextContainingUID (lldb::user_id_t uid) override;
 
+    void
+    ParseDeclsForContext (lldb_private::CompilerDeclContext decl_ctx) override;
+    
+
     uint32_t
     ResolveSymbolContext (const lldb_private::Address& so_addr,
                           uint32_t resolve_scope,
                           lldb_private::SymbolContext& sc) override;
 
     uint32_t
     ResolveSymbolContext (const lldb_private::FileSpec& file_spec,
                           uint32_t line,

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (parent_die)
                 if (die.GetAttributeValueAsUnsigned(DW_AT_virtuality, 0) != 0)
                     return true;
             }
         }
     }
     return false;
 }
 
+void
+SymbolFileDWARF::ParseDeclsForContext (CompilerDeclContext decl_ctx)
+{
+    TypeSystem *type_system = decl_ctx.GetTypeSystem();
+    DWARFASTParser *ast_parser = type_system->GetDWARFParser();
+    std::vector<DWARFDIE> decl_ctx_die_list = ast_parser->GetDIEForDeclContext(decl_ctx);
+
+    for (DWARFDIE decl_ctx_die : decl_ctx_die_list)
+        for (DWARFDIE decl = decl_ctx_die.GetFirstChild(); decl; decl = decl.GetSibling())
+            ast_parser->GetDeclForUIDFromDWARF(decl);
+}
+
 CompilerDecl
 SymbolFileDWARF::GetDeclForUID (lldb::user_id_t type_uid)
 {
     if (UserIDMatches(type_uid))
     {
         DWARFDebugInfo* debug_info = DebugInfo();
         if (debug_info)
         {

source/Symbol/ClangASTContext.cpp

else
                 parent_namespace_decl->addDecl (namespace_decl);
                 assert (namespace_decl == parent_namespace_decl->getAnonymousNamespace());
             }
             else
             {
                 // BAD!!!
             }
         }
-        
-
-        if (namespace_decl)
-        {
-            // If we make it here, we are creating the anonymous namespace decl
-            // for the first time, so we need to do the using directive magic
-            // like SEMA does
-            UsingDirectiveDecl* using_directive_decl = UsingDirectiveDecl::Create (*ast, 
-                                                                                   decl_ctx, 
-                                                                                   SourceLocation(),
-                                                                                   SourceLocation(),
-                                                                                   NestedNameSpecifierLoc(),
-                                                                                   SourceLocation(),
-                                                                                   namespace_decl,
-                                                                                   decl_ctx);
-            using_directive_decl->setImplicit();
-            decl_ctx->addDecl(using_directive_decl);
-        }
     }
 #ifdef LLDB_CONFIGURATION_DEBUG
     VerifyDecl(namespace_decl);
 #endif
     return namespace_decl;
 }
 
 
 clang::BlockDecl *
 ClangASTContext::CreateBlockDeclaration (clang::DeclContext *ctx)
 {
     if (ctx != nullptr)
     {
         clang::BlockDecl *decl = clang::BlockDecl::Create(*getASTContext(), ctx, clang::SourceLocation());
         ctx->addDecl(decl);
         return decl;
     }
     return nullptr;
 }
 
+clang::DeclContext *
+FindLCABetweenDecls(clang::DeclContext *left, clang::DeclContext *right, clang::DeclContext *root)
+{
+    if (root == nullptr)
+        return nullptr;
+
+    std::set<clang::DeclContext *> path_left;
+    for (clang::DeclContext *d = left; d != nullptr; d = d->getParent())
+        path_left.insert(d);
+
+    for (clang::DeclContext *d = right; d != nullptr; d = d->getParent())
+        if (path_left.find(d) != path_left.end())
+            return d;
+
+    return nullptr;
+}
+
 clang::UsingDirectiveDecl *
 ClangASTContext::CreateUsingDirectiveDeclaration (clang::DeclContext *decl_ctx, clang::NamespaceDecl *ns_decl)
 {
     if (decl_ctx != nullptr && ns_decl != nullptr)
     {
-        // TODO: run LCA between decl_tx and ns_decl
+        clang::TranslationUnitDecl *translation_unit = (clang::TranslationUnitDecl *)GetTranslationUnitDecl(getASTContext());
         clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create(*getASTContext(),
             decl_ctx,
             clang::SourceLocation(),
             clang::SourceLocation(),
             clang::NestedNameSpecifierLoc(),
             clang::SourceLocation(),
             ns_decl,
-            GetTranslationUnitDecl(getASTContext()));
+            FindLCABetweenDecls(decl_ctx, ns_decl, translation_unit));
         decl_ctx->addDecl(using_decl);
         return using_decl;
     }
     return nullptr;
 }
 
 clang::UsingDecl *
 ClangASTContext::CreateUsingDeclaration (clang::DeclContext *current_decl_ctx, clang::NamedDecl *target)
if (decl_context != nullptr)
             clang::SourceLocation(),
             clang::SourceLocation(),
             name && name[0] ? &getASTContext()->Idents.getOwn(name) : nullptr,
             type,
             nullptr,
             clang::SC_None);
         var_decl->setAccess(clang::AS_public);
         decl_context->addDecl(var_decl);
-        decl_context->makeDeclVisibleInContext(var_decl);
         return var_decl;
     }
     return nullptr;
 }
 
 #pragma mark Function Types
 
 FunctionDecl *

 ClangASTContext::DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name)
 {
     std::vector<void *> 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++)
             {
                 searched.insert(it->second);
+                symbol_file->ParseDeclsForContext(CompilerDeclContext(this, it->second));
+
                 for (clang::Decl *child : it->second->decls())
                 {
-                    if (clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(child))
-                    {
-                        IdentifierInfo *ii = nd->getIdentifier();
-                        if (ii != nullptr && ii->getName().equals(name.AsCString(nullptr)))
-                            found_decls.push_back(nd);
-                    }
-                    else if (clang::UsingDirectiveDecl *ud = llvm::dyn_cast<clang::UsingDirectiveDecl>(child))
+                    if (clang::UsingDirectiveDecl *ud = llvm::dyn_cast<clang::UsingDirectiveDecl>(child))
                     {
                         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))
                     {
                         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(nd);
                             }
                         }
                     }
+                    else if (clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(child))
+                    {
+                        IdentifierInfo *ii = nd->getIdentifier();
+                        if (ii != nullptr && ii->getName().equals(name.AsCString(nullptr)))
+                            found_decls.push_back(nd);
+                    }
                 }
             }
         }
     }
     return found_decls;
 }
 
 bool

test/lang/cpp/nsimport/TestCppNsImport.py

def check(self):
         self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 2, "anon = 2")
 
         test_result = frame.EvaluateExpression("global")
         self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 4, "global = 4")
 
         test_result = frame.EvaluateExpression("fun_var")
         self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 9, "fun_var = 9")
 
+        test_result = frame.EvaluateExpression("Fun::fun_var")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 0, "Fun::fun_var = 0")
+
         test_result = frame.EvaluateExpression("not_imported")
         self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 35, "not_imported = 35")
 
-        # Disabled the "imported" test since it isn't valid. It should actually test for ambiguity
-        #test_result = frame.EvaluateExpression("imported")
-        #self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 99, "imported = 99")
-
-        test_result = frame.EvaluateExpression("::imported")
-        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 89, "::imported = 89")
+        # Currently there is no way to distinguish between "::imported" and "imported" in ClangExpressionDeclMap so this fails
+        #test_result = frame.EvaluateExpression("::imported")
+        #self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 89, "::imported = 89")
 
         test_result = frame.EvaluateExpression("Imported::imported")
         self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 99, "Imported::imported = 99")
         
+        test_result = frame.EvaluateExpression("imported")
+        self.assertTrue(test_result.IsValid() and test_result.GetError().Fail(), "imported is ambiguous")
+
         test_result = frame.EvaluateExpression("single")
         self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 3, "single = 3")
 
         # Continue to second breakpoint
         process.Continue()
 
         # Get the thread of the process
         self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)