Fix for evaluating a function with an ambiguous symbol

[EwanCrawford]

Summary

I came across a bug for calling functions using expression evaluation, where the function name also matches a symbol from another compile unit.
The attached test case recreates it when compiled with gcc. Clang however doesn't seem to export a conflicting .rodata symbol so the bug doesn't appear.

Currently trying to call the function gives the following error in the test case.

(lldb) expr overloaded_symbol(1)
error: warning: got name from symbols: overloaded_symbol
error: reference to 'overloaded_symbol' is ambiguous
note: candidate found by name lookup is 'overloaded_symbol'
note: candidate found by name lookup is 'overloaded_symbol'
error: 1 errors parsing expression

This patch in the clang expression parser stops us turning the symbol into a global variable declaration if we've already found
a matching function. I'm not familiar with this code, so if there's a better way to fix this please let me know.

[EwanCrawford]

ping

[spyffe]

Sorry for getting to this review so late.
This looks all right, and pretty conservative. As long as the test suite is okay with it, this looks fine!
Thanks for the test case, too.

[EwanCrawford]

Thanks for getting around to looking at this Sean, i'd forgotten about it.
Unfortunately the patch seems to have gone stale as the test case no longer passes.
So i'm just going to close the review for now.

packages/Python/lldbsuite/test/expression_command/overloaded_symbol/Makefile

+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp overload.cpp
+
+include $(LEVEL)/Makefile.rules
+
+overload.o: overload.cpp
+  $(CXX) -c overload.cpp

packages/Python/lldbsuite/test/expression_command/overloaded_symbol/TestCallSymbolConflict.py

+"""
+Test calling function which has a name conflicting with a .rodata symbol
+"""
+
+from __future__ import print_function
+
+
+
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+class ExprCommandCallSymbolConfict(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break for main.c.
+        self.line = line_number('main.cpp', '// break here')
+
+    @expectedFlakeyDsym("llvm.org/pr20274")
+    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
+    def test(self):
+        """Test return value of call to function whose name conflicts with another symbol."""
+        self.build()
+
+        # Set breakpoint in main and run exe
+        self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
+        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # Function semantics are simply to return the incremented integer parameter
+        self.expect("expr overloaded_symbol(5)", substrs = ['$0 = 6'])

packages/Python/lldbsuite/test/expression_command/overloaded_symbol/main.cpp

+int return_global();
+
+int overloaded_symbol(int x)
+{
+    return x + 1;
+}
+
+int main()
+{
+    int my_local = return_global(); // break here
+    return overloaded_symbol(my_local);
+}

packages/Python/lldbsuite/test/expression_command/overloaded_symbol/overload.cpp

+const int overloaded_symbol = 2;
+
+int return_global()
+{
+    return overloaded_symbol;
+}

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

else
                             context.AddNamedDecl(copied_var_decl);
                             
                             context.m_found.variable = true;
                         }
                     }
                 } while (0);
             }
 
-            if (target && !context.m_found.variable && !namespace_decl)
+            if (target && !context.m_found.variable && !context.m_found.function && !context.m_found.function_with_type_info && !namespace_decl)
             {
                 // We couldn't find a non-symbol variable for this.  Now we'll hunt for a generic
                 // data symbol, and -- if it is found -- treat it as a variable.
 
                 const Symbol *data_symbol = FindGlobalDataSymbol(*target, name);
 
                 if (data_symbol)
                 {