Fix completion for functions in anonymous namespaces

[JDevlieghere]

Summary

I was going through some of the old bugs and came across PR21069 which I was able to reproduce. The issue is that we match the regex ^foo against the DW_AT_name in the DWARF, which for our anonymous function is indeed foo. However, when we get the function name from the symbol context, the result is (anonymous namespace)::foo(). This throws off completions, which assumes that it's appending to whatever is already present on the input, resulting in a bogus b fooonymous\ namespace)::foo().

I'm not super familiar with the completion framework, so please let me know if there's a better way to solve this issue.

https://bugs.llvm.org/show_bug.cgi?id=21069

[labath]

I don't immediately see a better way to fix this, but I'm not terribly familiar with this machinery either. I guess one day we may want to extend the completion machinery to be able to expand "foo<TAB>" into "(anonymous namespace)::foobar", but that's likely to be a larger undertaking...

[JDevlieghere]

In D65498#1607805, @labath wrote:

I don't immediately see a better way to fix this, but I'm not terribly familiar with this machinery either. I guess one day we may want to extend the completion machinery to be able to expand "foo<TAB>" into "(anonymous namespace)::foobar", but that's likely to be a larger undertaking...

Yep, that's how I wanted to fix this before I discovered that was going to be a lot harder than I hoped. :-)

[teemperor]

I think it's possible to rewrite the line when doing a completion, but I remember that I got annoyed when I tried understand the code responsible for that (and decipher the magic return values). Can you file a radar maybe and I'll fix this once I got around to refactor the related code? This patch can go IMHO, so LGTM.

[JDevlieghere]

In D65498#1607819, @teemperor wrote:

I think it's possible to rewrite the line when doing a completion, but I remember that I got annoyed when I tried understand the code responsible for that (and decipher the magic return values). Can you file a radar maybe and I'll fix this once I got around to refactor the related code? This patch can go IMHO, so LGTM.

I think we could solve this issue by storing more information with the candidates, like a bit that says that we should clear (part) of the current line. However, currently candidates are stored in StringLists, which do not have such capabilities. The part that rewrites the line should be relatively straightforward.

I've filed rdar://53769355. I might come back to it myself as I'd like to have this non-prefix completion functionality.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/completion/TestCompletion.py

class CommandLineCompletionTestCase(TestBase):
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
     def test_symbol_name(self):
         self.build()
         self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.complete_from_to('breakpoint set -n Fo',
                               'breakpoint set -n Foo::Bar(int,\\ int)',
                               turn_off_re_match=True)
+        # No completion for Qu because the candidate is
+        # (anonymous namespace)::Quux().
+        self.complete_from_to('breakpoint set -n Qu', '')

lldb/trunk/packages/Python/lldbsuite/test/functionalities/completion/main.cpp

 class Foo
 {
 public:
     int Bar(int x, int y)
     {
         return x + y;
     }
 };
 
+namespace { int Quux (void) { return 0; } }
+
 struct Container { int MemberVar; };
 
 int main()
 {
     Foo fooo;
     Foo *ptr_fooo = &fooo;
     fooo.Bar(1, 2);
 
     Container container;
     Container *ptr_container = &container;
+    int q = Quux();
     return container.MemberVar = 3; // Break here
 }

lldb/trunk/source/Commands/CommandCompletions.cpp

if (context.module_sp) {
     context.module_sp->FindFunctions(m_regex, include_symbols, include_inlines,
                                      append, sc_list);
 
     SymbolContext sc;
     // Now add the functions & symbols to the list - only add if unique:
     for (uint32_t i = 0; i < sc_list.GetSize(); i++) {
       if (sc_list.GetContextAtIndex(i, sc)) {
         ConstString func_name = sc.GetFunctionName(Mangled::ePreferDemangled);
-        if (!func_name.IsEmpty())
+        // Ensure that the function name matches the regex. This is more than a
+        // sanity check. It is possible that the demangled function name does
+        // not start with the prefix, for example when it's in an anonymous
+        // namespace.
+        if (!func_name.IsEmpty() && m_regex.Execute(func_name.GetStringRef()))
           m_match_set.insert(func_name);
       }
     }
   }
   return Searcher::eCallbackReturnContinue;
 }
 
 size_t CommandCompletions::SymbolCompleter::DoCompletion(SearchFilter *filter) {