[clang] Support function pointer types with attributes when extracting parameter names for signature help

[nridge]

Summary

Fixes https://github.com/clangd/clangd/issues/1729

[sammccall]

clang/lib/Sema/SemaCodeComplete.cpp

6069

By unwrapping these in a fixed order, we'll successfully unwrap a pointer to an attributed function type, but not an attributed pointer to function type.

Maybe extract a recursive function so we can unwrap arbitrary sequences of sugar?

[nridge]

Address review comment

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

EXPECT_THAT(Results.signatures,
                                    sig("foo([[int x]], [[float y]]) -> void"),
                                    sig("foo([[int x]], [[int y]]) -> void")));
   // We always prefer the first signature.
   EXPECT_EQ(0, Results.activeSignature);
   EXPECT_EQ(0, Results.activeParameter);
 }
 
 TEST(SignatureHelpTest, FunctionPointers) {
-  auto FunctionPointerResults = signatures(R"cpp(
+  llvm::StringLiteral Tests[] = {
+      // Variable of function pointer type
+      R"cpp(
     void (*foo)(int x, int y);
     int main() { foo(^); }
-  )cpp");
-  EXPECT_THAT(FunctionPointerResults.signatures,
-              UnorderedElementsAre(sig("([[int x]], [[int y]]) -> void")));
-
-  auto FunctionPointerTypedefResults = signatures(R"cpp(
+  )cpp",
+      // Wrapped in an AttributedType
+      R"cpp(
+    void (__stdcall *foo)(int x, int y);
+    int main() { foo(^); }
+  )cpp",
+      // Another syntax for an AttributedType
+      R"cpp(
+    void (__attribute__(stdcall) *foo)(int x, int y);
+    int main() { foo(^); },
+  )cpp",
+      // Wrapped in a typedef
+      R"cpp(
     typedef void (*fn)(int x, int y);
     fn foo;
     int main() { foo(^); }
-  )cpp");
-  EXPECT_THAT(FunctionPointerTypedefResults.signatures,
+  )cpp",
+      // Wrapped in both a typedef and an AttributedTyped
+      R"cpp(
+    typedef void (__stdcall *fn)(int x, int y);
+    fn foo;
+    int main() { foo(^); }
+  )cpp"};
+  for (auto Test : Tests)
+    EXPECT_THAT(signatures(Test).signatures,
                 UnorderedElementsAre(sig("([[int x]], [[int y]]) -> void")));
 }
 
 TEST(SignatureHelpTest, Constructors) {
   std::string Top = R"cpp(
     struct S {
       S(int);
       S(const S &) = delete;
     };

clang/lib/Sema/SemaCodeComplete.cpp

if (const auto *T = Fn->getType().getTypePtr()->getAs<TypedefType>()) {
     if (const auto *const VD = dyn_cast<VarDecl>(D)) {
       Target = VD->getTypeSourceInfo()->getTypeLoc();
     }
   }
 
   if (!Target)
     return {};
 
+  // Unwrap types that may be wrapping the function type
+  while (true) {
     if (auto P = Target.getAs<PointerTypeLoc>()) {
       Target = P.getPointeeLoc();
+      continue;
+    }
+    if (auto A = Target.getAs<AttributedTypeLoc>()) {
+      Target = A.getModifiedLoc();
+      continue;
     }
-
     if (auto P = Target.getAs<ParenTypeLoc>()) {
       Target = P.getInnerLoc();
+      continue;
+    }
+    break;
   }
 
   if (auto F = Target.getAs<FunctionProtoTypeLoc>()) {
     return F;
   }
 
   return {};
 }