[WIP] [clangd] Tests for special methods code-completion

[jkorous]

Summary

Created in order to check we agree on what are the requirements and would later write patches against these.

Currently these are failing:
[ FAILED ] CompletionTestNoExplicitMembers.Struct
[ FAILED ] CompletionTestNoExplicitMembers.StructTemplate
[ FAILED ] CompletionTestNoExplicitMembers.ExplicitStructTemplateSpecialization
[ FAILED ] CompletionTestMethodDeclared.ExplicitStructTemplateSpecialization
[ FAILED ] CompletionTestSpecialMethodsDeclared.Struct
[ FAILED ] CompletionTestSpecialMethodsDeclared.StructTemplate
[ FAILED ] CompletionTestSpecialMethodsDeclared.ExplicitStructTemplateSpecialization

[sammccall]

The assertions themselves all look good to me.

I don't think these should be new tests, they have substantial overlap with TestAfterDotCompletion and should be incorporated there or those tests split up to reduce the duplication.
(It's hard to avoid overlap/redundancy between tests, and to do so while covering all cases in a systematic way, but it's important for maintenance: one of the reasons it's hard to find the overlapping test here is there are so many!)

clangd/CodeCompleteTests.cpp

2043

(Should this be ImplicitMembers?)

2043

nit: these cases should probably be moved up with the other code completion ones, and called something like TEST(CompletionTest, NoExplicitMembers) or so for consistency.

It's OK to have related tests in one test case.

In fact, this large set of closely-related cases seems like a good place for Go-style table-driven tests.

2045

(not clear why the limit is needed?)

2054

EXPECT_THAT(ResultsDot.Completions, IsEmpty())

(when the assertion fails, the failure message will print the contents of the container)

2139

doesn't this test a strict superset of what CompletionTestNoTestMembers tests?
i.e. this also asserts that the implicit members are not included.

ISTM we could combine many of these tests (and that in fact many of them are covered by TestAfterDotCompletion.

2150

EXPECT_THAT(ResultsDot.Completions, ElementsAre(Named("foomethod")));

(As above, this is equivalent to the two assertions here but gives useful failure messages)

2338

(I think we could get away with a representative set of cases, rather than testing the intersection of every feature. e.g. test an explicitly declared operator= on a struct, but combining that with an explicitly specialized struct template seems unneccesary)

[jkorous]

clangd/CodeCompleteTests.cpp

2043

Ultimately got rid of the name completely.

2043

I reconsidered the simple yet verbatim approach.

2054

I didn't know this. It's pretty neat. Thanks!

2139

You are right, I pruned the list of testcases a bit.

2338

I simplified the whole test and removed some cases that were not really unique. Do you think the rest is still too exhaustive? (Asking before deleting.)

[jkorous]

Rewritten tests to shared implementation different cases.

clangd/CodeCompleteTests.cpp

TEST(SignatureHelpTest, ConstructorInitializeFields) {
     EXPECT_THAT(Results.signatures, UnorderedElementsAre(
             Sig("A(int)", {"int"}),
             Sig("A(A &&)", {"A &&"}),
             Sig("A(const A &)", {"const A &"})
         ));
   }
 }
 
+TEST(CompletionTestNoExplicitMembers, Struct) {
+  clangd::CodeCompleteOptions Opts;
+  Opts.Limit = 1;
+  auto ResultsDot = completions(R"cpp(
+      struct foo {};
+      void bar() {
+        foo a;
+        a.^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsDot.Completions.empty());
+
+  auto ResultsArrow = completions(R"cpp(
+      struct foo {};
+      void bar() {
+        foo* b;
+        b->^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsArrow.Completions.empty());
+
+  auto ResultsQualified = completions(R"cpp(
+      struct foo {};
+      foo::^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsQualified.Completions.empty());
+}
+
+TEST(CompletionTestNoExplicitMembers, StructTemplate) {
+  clangd::CodeCompleteOptions Opts;
+  Opts.Limit = 1;
+  auto ResultsDot = completions(R"cpp(
+      template<class T> struct foo {};
+      void bar() {
+        foo<int> a;
+        a.^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsDot.Completions.empty());
+
+  auto ResultsArrow = completions(R"cpp(
+      template<class T> struct foo {};
+      void bar() {
+        foo<int>* b;
+        b->^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsArrow.Completions.empty());
+
+  auto ResultsQualified = completions(R"cpp(
+      template<class T> struct foo {};
+      foo<int>::^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsQualified.Completions.empty());
+}
+
+TEST(CompletionTestNoExplicitMembers, ExplicitStructTemplateSpecialization) {
+  clangd::CodeCompleteOptions Opts;
+  Opts.Limit = 1;
+  auto ResultsDot = completions(R"cpp(
+      template<class T> struct foo {}; template<> struct foo<bool> {};
+      void bar() {
+        foo<bool> a;
+        a.^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsDot.Completions.empty());
+
+  auto ResultsArrow = completions(R"cpp(
+      template<class T> struct foo {}; template<> struct foo<bool> {};
+      void bar() {
+        foo<bool>* b;
+        b->^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsArrow.Completions.empty());
+
+  auto ResultsQualified = completions(R"cpp(
+      template<class T> struct foo {}; template<> struct foo<bool> {};
+      foo<bool>::^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsQualified.Completions.empty());
+}
+
+TEST(CompletionTestMethodDeclared, Struct) {
+  clangd::CodeCompleteOptions Opts;
+  Opts.Limit = 1;
+  auto ResultsDot = completions(R"cpp(
+      struct foo { void foomethod(); };
+      void bar() {
+        foo a;
+        a.^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  ASSERT_TRUE(ResultsDot.Completions.size() == 1);
+  EXPECT_TRUE(ResultsDot.Completions.front().Name == "foomethod");
+
+  auto ResultsArrow = completions(R"cpp(
+      struct foo { void foomethod(); };
+      void bar() {
+        foo* b;
+        b->^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  ASSERT_TRUE(ResultsArrow.Completions.size() == 1);
+  EXPECT_TRUE(ResultsArrow.Completions.front().Name == "foomethod");
+
+  auto ResultsQualified = completions(R"cpp(
+      struct foo { void foomethod(); };
+      foo::^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  ASSERT_TRUE(ResultsQualified.Completions.size() == 1);
+  EXPECT_TRUE(ResultsQualified.Completions.front().Name == "foomethod");
+
+  auto ResultsQualifiedStatic = completions(R"cpp(
+      struct foo { static void foomethod(); };
+      void bar() {
+        foo::^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  ASSERT_TRUE(ResultsQualifiedStatic.Completions.size() == 1);
+  EXPECT_TRUE(ResultsQualifiedStatic.Completions.front().Name == "foomethod");
+}
+
+TEST(CompletionTestMethodDeclared, StructTemplate) {
+  clangd::CodeCompleteOptions Opts;
+  Opts.Limit = 1;
+  auto ResultsDot = completions(R"cpp(
+      template<class T> struct foo { void foomethod(); };
+      void bar() {
+        foo<int> a;
+        a.^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  ASSERT_TRUE(ResultsDot.Completions.size() == 1);
+  EXPECT_TRUE(ResultsDot.Completions.front().Name == "foomethod");
+
+  auto ResultsArrow = completions(R"cpp(
+      template<class T> struct foo { void foomethod(); };
+      void bar() {
+        foo<int>* b;
+        b->^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  ASSERT_TRUE(ResultsArrow.Completions.size() == 1);
+  EXPECT_TRUE(ResultsArrow.Completions.front().Name == "foomethod");
+
+  auto ResultsQualified = completions(R"cpp(
+      template<class T> struct foo { void foomethod(); };
+      foo<int>::^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  ASSERT_TRUE(ResultsQualified.Completions.size() == 1);
+  EXPECT_TRUE(ResultsQualified.Completions.front().Name == "foomethod");
+
+  auto ResultsQualifiedStatic = completions(R"cpp(
+      template<class T> struct foo { static void foomethod(); };
+      void bar() {
+        foo<int>::^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  ASSERT_TRUE(ResultsQualifiedStatic.Completions.size() == 1);
+  EXPECT_TRUE(ResultsQualifiedStatic.Completions.front().Name == "foomethod");
+}
+
+TEST(CompletionTestMethodDeclared, ExplicitStructTemplateSpecialization) {
+  clangd::CodeCompleteOptions Opts;
+  Opts.Limit = 1;
+  auto ResultsDot = completions(R"cpp(
+      template<class T> struct foo { void foomethod_T(); }; template<> struct foo<bool> { void foomethod_bool(); };
+      void bar() {
+        foo<bool> a;
+        a.^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  ASSERT_TRUE(ResultsDot.Completions.size() == 1);
+  EXPECT_TRUE(ResultsDot.Completions.front().Name == "foomethod_bool");
+
+  auto ResultsArrow = completions(R"cpp(
+      template<class T> struct foo { void foomethod_T(); }; template<> struct foo<bool> { void foomethod_bool(); };
+      void bar() {
+        foo<int>* b;
+        b->^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  ASSERT_TRUE(ResultsArrow.Completions.size() == 1);
+  EXPECT_TRUE(ResultsArrow.Completions.front().Name == "foomethod_bool");
+
+  auto ResultsQualified = completions(R"cpp(
+      template<class T> struct foo { void foomethod_T(); }; template<> struct foo<bool> { void foomethod_bool(); };
+      foo<int>::^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  ASSERT_TRUE(ResultsQualified.Completions.size() == 1);
+  EXPECT_TRUE(ResultsQualified.Completions.front().Name == "foomethod_bool");
+
+  auto ResultsQualifiedStatic = completions(R"cpp(
+      template<class T> struct foo { static void foomethod_T(); }; template<> struct foo<bool> { static void foomethod_bool(); };
+      void bar() {
+        foo<bool>::^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  ASSERT_TRUE(ResultsQualifiedStatic.Completions.size() == 1);
+  EXPECT_TRUE(ResultsQualifiedStatic.Completions.front().Name == "foomethod_bool");
+}
+
+TEST(CompletionTestSpecialMethodsDeclared, Struct) {
+  clangd::CodeCompleteOptions Opts;
+  Opts.Limit = 1;
+  auto ResultsDot = completions(R"cpp(
+      struct foo { foo(); ~foo(); foo& operator=(const foo&); foo& operator=(foo&&); };
+      void bar() {
+        foo a;
+        a.^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsDot.Completions.empty());
+
+  auto ResultsArrow = completions(R"cpp(
+      struct foo { foo(); ~foo(); foo& operator=(const foo&); foo& operator=(foo&&); };
+      void bar() {
+        foo* b;
+        b->^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsArrow.Completions.empty());
+
+  auto ResultsQualified = completions(R"cpp(
+      struct foo { foo(); ~foo(); foo& operator=(const foo&); foo& operator=(foo&&); };
+      foo::^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsQualified.Completions.empty());
+}
+
+TEST(CompletionTestSpecialMethodsDeclared, StructTemplate) {
+  clangd::CodeCompleteOptions Opts;
+  Opts.Limit = 1;
+  auto ResultsDot = completions(R"cpp(
+      template<class T> struct foo { foo(); ~foo(); foo& operator=(const foo&); foo& operator=(foo&&); };
+      void bar() {
+        foo<int> a;
+        a.^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsDot.Completions.empty());
+
+  auto ResultsArrow = completions(R"cpp(
+      template<class T> struct foo { foo(); ~foo(); foo& operator=(const foo&); foo& operator=(foo&&); };
+      void bar() {
+        foo<int>* b;
+        b->^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsArrow.Completions.empty());
+
+  auto ResultsQualified = completions(R"cpp(
+      template<class T> struct foo { foo(); ~foo(); foo& operator=(const foo&); foo& operator=(foo&&); };
+      foo<int>::^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsQualified.Completions.empty());
+}
+
+TEST(CompletionTestSpecialMethodsDeclared, ExplicitStructTemplateSpecialization) {
+  clangd::CodeCompleteOptions Opts;
+  Opts.Limit = 1;
+  auto ResultsDot = completions(R"cpp(
+      template<class T> struct foo { foo(); ~foo(); foo& operator=(const foo&); foo& operator=(foo&&); };
+      template<> struct foo<bool> { foo(); ~foo(); foo& operator=(const foo&); foo& operator=(foo&&); };
+      void bar() {
+        foo<bool> a;
+        a.^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsDot.Completions.empty());
+
+  auto ResultsArrow = completions(R"cpp(
+      template<class T> struct foo { foo(); ~foo(); foo& operator=(const foo&); foo& operator=(foo&&); };
+      template<> struct foo<bool> { foo(); ~foo(); foo& operator=(const foo&); foo& operator=(foo&&); };
+      void bar() {
+        foo<bool>* b;
+        b->^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsArrow.Completions.empty());
+
+  auto ResultsQualified = completions(R"cpp(
+      template<class T> struct foo { foo(); ~foo(); foo& operator=(const foo&); foo& operator=(foo&&); };
+      template<> struct foo<bool> { foo(); ~foo(); foo& operator=(const foo&); foo& operator=(foo&&); };
+      foo<bool>::^
+    )cpp",
+    /*IndexSymbols=*/{}, Opts);
+
+  EXPECT_TRUE(ResultsQualified.Completions.empty());
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang