jkorous created this revision.
jkorous added reviewers: sammccall, ilya-biryukov.
jkorous added a project: clang-tools-extra.
Herald added subscribers: cfe-commits, kadircet, arphaman, dexonsmith, MaskRay,
ioeric.
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
Repository:
rCTE Clang Tools Extra
https://reviews.llvm.org/D52554
Files:
clangd/CodeCompleteTests.cpp
Index: clangd/CodeCompleteTests.cpp
===================================================================
--- clangd/CodeCompleteTests.cpp
+++ clangd/CodeCompleteTests.cpp
@@ -2040,6 +2040,336 @@
}
}
+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
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
