[Sema] Provide constructor signature help for smart pointer factories

[nridge]

Adding a link to the issue that this pertains to: https://github.com/clangd/clangd/issues/447

[nridge]

This direction looks promising to me.

There is precedent for having a config option whose value is a list of qualified names (https://clangd.llvm.org/config.html#fullyqualifiednamespaces), we could have a similar setting for the user to specify custom smart pointer factory names like QSharedPointer::create.

clang/lib/Sema/SemaCodeComplete.cpp

6122

If we generalize this to user-specified factory functions, getAsType() will need a null check here (in case the user mistakenly specified a function with a non-type template argument), and likewise below.

(Maybe it doesn't hurt to have a null check even now, in case it can produce a null type in the presence of invalid code or something?)

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

for (auto Range : A.ranges()) {
     ExpectedParameter &P = Parameters.back();
     P.Text = Label.substr(Range.Begin, Range.End - Range.Begin);
     P.Offsets.first = lspLength(llvm::StringRef(Label).substr(0, Range.Begin));
     P.Offsets.second = lspLength(llvm::StringRef(Label).substr(1, Range.End));
   }
   return AllOf(sigHelpLabeled(Label), paramsAre(Parameters));
 }
 
+TEST(SignatureHelpTest, SmartPointerFactoryFunctions) {
+  auto Code = Annotations(R"cpp(
+    namespace std { 
+    template<class T, class... Args>
+    T make_unique(Args&&... args);
+    template<class T, class... Args>
+    T make_shared(Args&&... args);
+    }
+    template <class T>
+    struct QSharedPointer {
+        template <class ...Args>
+        static T create(Args&&... args);
+    };
+    struct Foo {
+        Foo(int x, int y) {}
+        Foo(float x, float y) {}
+    };
+    int main() { 
+        std::make_shared<Foo>(1, ^);
+        std::make_unique<Foo>(1, ^);
+        QSharedPointer<Foo>::create(1, ^); 
+    }
+  )cpp");
+  for (auto Point : Code.points()) {
+    auto Results = signatures(Code.code(), Point);
+    EXPECT_THAT(Results.signatures,
+                ElementsAre(sig("Foo([[int x]], [[int y]])"),
+                            sig("Foo([[float x]], [[float y]])")));
+    EXPECT_EQ(0, Results.activeSignature);
+    EXPECT_EQ(1, Results.activeParameter);
+  }
+}
+
 TEST(SignatureHelpTest, Overloads) {
   auto Results = signatures(R"cpp(
     void foo(int x, int y);
     void foo(int x, float y);
     void foo(float x, int y);
     void foo(float x, float y);
     void bar(int x, int y = 0);
     int main() { foo(^); }

clang/lib/Sema/SemaCodeComplete.cpp

QualType Sema::ProduceCallSignatureHelp(Expr *Fn, ArrayRef<Expr *> Args,
   SmallVector<ResultCandidate, 8> Results;
 
   Expr *NakedFn = Fn->IgnoreParenCasts();
   // Build an overload candidate set based on the functions we find.
   SourceLocation Loc = Fn->getExprLoc();
   OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
 
   if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn)) {
+    if (ULE->getNumDecls() > 0) {
+      std::string QualifiedName;
+      llvm::raw_string_ostream OS(QualifiedName);
+      if (const auto *NC = ULE->getNamingClass()) {
+        NC->printQualifiedName(OS);
+        OS << "::";
+        ULE->decls().begin()->printName(OS);
+
+        if (QualifiedName == "QSharedPointer::create") {
+          if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(
+                  ULE->getNamingClass())) {
+            const auto &TemplateArgs = CTSD->getTemplateArgs();
+            if (TemplateArgs.size() == 1) {
+              return ProduceConstructorSignatureHelp(
+                  TemplateArgs[0].getAsType(), OpenParLoc, Args, OpenParLoc,
+                  false);
+            }
+          }
+        }
+      } else {
+        ULE->decls().begin()->printQualifiedName(OS);
+        if (QualifiedName == "std::make_unique" ||
+            QualifiedName == "std::make_shared") {
+          if (ULE->getNumTemplateArgs() == 1) {
+            return ProduceConstructorSignatureHelp(
+                ULE->template_arguments().front().getArgument().getAsType(), OpenParLoc,
+                Args, OpenParLoc, false);
+          }
+        }
+      }
+    }
+
     AddOverloadedCallCandidates(ULE, ArgsWithoutDependentTypes, CandidateSet,
                                 /*PartialOverloading=*/true);
   } else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
     TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
     if (UME->hasExplicitTemplateArgs()) {
       UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
       TemplateArgs = &TemplateArgsBuffer;
     }