[clangd] Fix function-arg-placeholder suppression with macros.

[sammccall]

Summary

While here, unhide function-arg-placeholders flag. It's reasonable to want and
maybe we should consider making it default.

[kadircet]

clang-tools-extra/clangd/CodeComplete.cpp

476

while here, i suppose we should perform drop arguments and parentheses magic for macros as well?

517

again while here, maybe introduce constructors into this condition. (Even better, what about a bool isFunctionLikeCompletion(const CompletionItem&) that we can use both here and above?)

[sammccall]

Address review comments.
While here, condense some long comments that repeated the code and seemed confusing.

clang-tools-extra/clangd/CodeComplete.cpp

517

Done, though I didn't want to extract the variable too far away as there are some wrinkles (macros may not be function-like, template args...) that we can get away without resolving here.

[kadircet]

clang-tools-extra/clangd/CodeComplete.cpp

517

thanks! yes that makes sense.

clang-tools-extra/clangd/CodeComplete.cpp

if (!Snippet)
       return "($0)";
     // Suppress function argument snippets cursor is followed by left
     // parenthesis (and potentially arguments) or if there are potentially
     // template arguments. There are cases where it would be wrong (e.g. next
     // '<' token is a comparison rather than template argument list start) but
     // it is less common and suppressing snippet provides better UX.
     if (Completion.Kind == CompletionItemKind::Function ||
         Completion.Kind == CompletionItemKind::Method ||
         Completion.Kind == CompletionItemKind::Constructor) {
       // If there is a potential template argument list, drop snippet and just
       // complete symbol name. Ideally, this could generate an edit that would
       // paste function arguments after template argument list but it would be
       // complicated. Example:
       //
       // fu^<int> -> function<int>
       if (NextTokenKind == tok::less && Snippet->front() == '<')
         return "";
std::string summarizeSnippet() const {
     }
     if (EnableFunctionArgSnippets)
       return *Snippet;
 
     // Replace argument snippets with a simplified pattern.
     if (Snippet->empty())
       return "";
     if (Completion.Kind == CompletionItemKind::Function ||
-        Completion.Kind == CompletionItemKind::Method) {
+        Completion.Kind == CompletionItemKind::Method ||
+        Completion.Kind == CompletionItemKind::Text /*Macro*/) {
       // Functions snippets can be of 2 types:
       // - containing only function arguments, e.g.
       //   foo(${1:int p1}, ${2:int p2});
       //   We transform this pattern to '($0)' or '()'.
       // - template arguments and function arguments, e.g.
       //   foo<${1:class}>(${2:int p1}).
       //   We transform this pattern to '<$1>()$0' or '<$0>()'.
 

clang-tools-extra/clangd/tool/ClangdMain.cpp

 
 opt<bool> EnableFunctionArgSnippets{
     "function-arg-placeholders",
     cat(Features),
     desc("When disabled, completions contain only parentheses for "
          "function calls. When enabled, completions also contain "
          "placeholders for method parameters"),
     init(CodeCompleteOptions().EnableFunctionArgSnippets),
-    Hidden,
 };
 
 opt<CodeCompleteOptions::IncludeInsertion> HeaderInsertion{
     "header-insertion",
     cat(Features),
     desc("Add #include directives when accepting code completions"),
     init(CodeCompleteOptions().InsertIncludes),
     values(

clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp

auto Results = completions(
       using foo_alias = T**;
       void f() { foo_^ })cpp",
         {}, Opts);
     EXPECT_THAT(
         Results.Completions,
         UnorderedElementsAre(AllOf(Named("foo_class"), SnippetSuffix("<$0>")),
                              AllOf(Named("foo_alias"), SnippetSuffix("<$0>"))));
   }
+  {
+    auto Results = completions(
+        R"cpp(
+      #define FOO(x, y) x##f
+      FO^ )cpp",
+        {}, Opts);
+    EXPECT_THAT(Results.Completions, UnorderedElementsAre(AllOf(
+                                         Named("FOO"), SnippetSuffix("($0)"))));
+  }
 }
 
 TEST(CompletionTest, SuggestOverrides) {
   constexpr const char *const Text(R"cpp(
   class A {
    public:
     virtual void vfunc(bool param);
     virtual void vfunc(bool param, int p);