[expression evaluation] Prevent invalid function declarations ending up in clang AST

[ldrumm]

Summary

Due to the way the lldb override for clang::ExternalASTSource::FindExternalGlobalVisibleDeclsByName callback was searching for functions, it was possible for invalid declarations to end up in the list of function declarations passed back to the clang AST, which subsequently caused clang to complain about ambiguous lookups. The logic used to prune duplicate function declarations based on lexical distance was ignoring the error status returned for invalid declarations which meant that they ended up in the list of resolved declarations passed back to clang.

[jingham]

Shouldn't it be the job of the subsequent filtering loop to sort this out? The debugger should be able to call functions from a given frame, even if that function is not actually visible from the current frame. So I don't think you want to reject such functions from the candidate list. You just want to make sure that if there IS one visible, it should override the ones that aren't visible.

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

else
                             // lower count will be closer to us in the lookup scope and
                             // shadows the other.
                             clang::DeclContext *func_decl_ctx = (clang::DeclContext *)func_decl_context.GetOpaqueDeclContext();
                             fdi.m_decl_lvl = ast->CountDeclLevels(frame_decl_ctx,
                                                                   func_decl_ctx,
                                                                   &fdi.m_name,
                                                                   &fdi.m_copied_type);
                         }
+                        if (fdi.m_decl_lvl == LLDB_INVALID_DECL_LEVEL)
+                        {
+                            if (log)
+                                log->Printf("INVALID_DECL_LEVEL for function declaration '%s'",
+                                            fdi.m_name.GetCString());
+                        }
+                        else
                             fdi_cache.emplace_back(fdi);
                     }
 
                     // Loop through the functions in our cache looking for matching types,
                     // then compare their scope levels to see which is closer.
                     std::multimap<CompilerType, const FuncDeclInfo*> matches;
                     for (const FuncDeclInfo &fdi : fdi_cache)
                     {
                         const CompilerType t = fdi.m_copied_type;