This is an archive of the discontinued LLVM Phabricator instance.

Differential D70911

[clangd] Switch Hover.All to structured tests
ClosedPublic

Authored by kadircet on Dec 2 2019, 10:35 AM.

Details

Reviewers
sammccall
Commits
rGc5adbac9b85a: [clangd] Switch Hover.All to structured tests

Diff Detail

Event Timeline

kadircet created this revision.Dec 2 2019, 10:35 AM
Herald added a project: Restricted Project. · View Herald TranscriptDec 2 2019, 10:35 AM
Herald added subscribers: cfe-commits, usaxena95, arphaman and 3 others. · View Herald Transcript
merge_guards_bot added a subscriber: merge_guards_bot.Dec 2 2019, 10:44 AM

Build result: FAILURE -
Log files: console-log.txt, CMakeCache.txt

Harbormaster failed remote builds in B41727: Diff 231735!Dec 2 2019, 10:45 AM
kadircet added a child revision: D71063: [clangd] New rendering structs.Dec 5 2019, 6:13 AM
kadircet added a parent revision: D70723: [clangd] Store index::SymbolKind in HoverInfo.
sammccall accepted this revision.Dec 5 2019, 10:05 AM
This revision is now accepted and ready to land.Dec 5 2019, 10:05 AM
Closed by commit rGc5adbac9b85a: [clangd] Switch Hover.All to structured tests (authored by kadircet). · Explain WhyDec 6 2019, 4:48 AM
This revision was automatically updated to reflect the committed changes.
sammccall mentioned this in D71248: [clangd] Introduce paragraph, the first part of new rendering structs.Dec 11 2019, 12:28 AM

Revision Contents

PathSize
clang-tools-extra/
clangd/
unittests/
915 lines

Diff 231735

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

//===-- HoverTests.cpp ----------------------------------------------------===// //===-- HoverTests.cpp ----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "Annotations.h" #include "Annotations.h"
#include "Hover.h" #include "Hover.h"
#include "TestIndex.h" #include "TestIndex.h"
#include "TestTU.h" #include "TestTU.h"
#include "index/MemIndex.h" #include "index/MemIndex.h"
#include "clang/Index/IndexSymbol.h"
#include "llvm/ADT/None.h"
#include "llvm/ADT/StringRef.h"
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <string>
#include <vector>
namespace clang { namespace clang {
namespace clangd { namespace clangd {
namespace { namespace {
TEST(Hover, Structured) { TEST(Hover, Structured) {
struct { struct {
const char *const Code; const char *const Code;
▲ Show 20 Lines • Show All 502 Lines • ▼ Show 20 Lines for (const auto &Case : Cases) {
EXPECT_EQ(H->ReturnType, Expected.ReturnType); EXPECT_EQ(H->ReturnType, Expected.ReturnType);
EXPECT_EQ(H->Parameters, Expected.Parameters); EXPECT_EQ(H->Parameters, Expected.Parameters);
EXPECT_EQ(H->TemplateParameters, Expected.TemplateParameters); EXPECT_EQ(H->TemplateParameters, Expected.TemplateParameters);
EXPECT_EQ(H->SymRange, Expected.SymRange); EXPECT_EQ(H->SymRange, Expected.SymRange);
EXPECT_EQ(H->Value, Expected.Value); EXPECT_EQ(H->Value, Expected.Value);
} }
} }
TEST(Hover, All) { TEST(Hover, NoHover) {
struct OneTest { llvm::StringRef Tests[] = {
StringRef Input; "^int main() {}",
StringRef ExpectedHover; "void foo() {^}",
R"cpp(// structured binding. Not supported yet
struct Bar {};
void foo() {
Bar a[2];
^auto [x,y] = a;
}
)cpp",
R"cpp(// Template auto parameter. Nothing (Not useful).
template<^auto T>
void func() {
}
void foo() {
func<1>();
}
)cpp",
}; };
OneTest Tests[] = { for (const auto &Test : Tests) {
{ SCOPED_TRACE(Test);
R"cpp(// No hover
^int main() { Annotations T(Test);
TestTU TU = TestTU::withCode(T.code());
TU.ExtraArgs.push_back("-std=c++17");
auto AST = TU.build();
ASSERT_TRUE(AST.getDiagnostics().empty());
auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
ASSERT_FALSE(H);
} }
)cpp", }
"",
}, TEST(Hover, All) {
struct {
const char *const Code;
const std::function<void(HoverInfo &)> ExpectedBuilder;
} Cases[] = {
{ {
R"cpp(// Local variable R"cpp(// Local variable
int main() { int main() {
int bonjour; int bonjour;
^bonjour = 2; ^[[bonjour]] = 2;
int test1 = bonjour; int test1 = bonjour;
} }
)cpp", )cpp",
"text[Declared in]code[main]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "bonjour";
"int bonjour\n" HI.Kind = index::SymbolKind::Variable;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "main::";
HI.Type = "int";
HI.Definition = "int bonjour";
}},
{ {
R"cpp(// Local variable in method R"cpp(// Local variable in method
struct s { struct s {
void method() { void method() {
int bonjour; int bonjour;
^bonjour = 2; ^[[bonjour]] = 2;
} }
}; };
)cpp", )cpp",
"text[Declared in]code[s::method]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "bonjour";
"int bonjour\n" HI.Kind = index::SymbolKind::Variable;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "s::method::";
HI.Type = "int";
HI.Definition = "int bonjour";
}},
{ {
R"cpp(// Struct R"cpp(// Struct
namespace ns1 { namespace ns1 {
struct MyClass {}; struct MyClass {};
} // namespace ns1 } // namespace ns1
int main() { int main() {
ns1::My^Class* Params; ns1::[[My^Class]]* Params;
} }
)cpp", )cpp",
"text[Declared in]code[ns1]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "MyClass";
"struct MyClass {}\n" HI.Kind = index::SymbolKind::Struct;
"]", HI.NamespaceScope = "ns1::";
}, HI.Definition = "struct MyClass {}";
}},
{ {
R"cpp(// Class R"cpp(// Class
namespace ns1 { namespace ns1 {
class MyClass {}; class MyClass {};
} // namespace ns1 } // namespace ns1
int main() { int main() {
ns1::My^Class* Params; ns1::[[My^Class]]* Params;
} }
)cpp", )cpp",
"text[Declared in]code[ns1]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "MyClass";
"class MyClass {}\n" HI.Kind = index::SymbolKind::Class;
"]", HI.NamespaceScope = "ns1::";
}, HI.Definition = "class MyClass {}";
}},
{ {
R"cpp(// Union R"cpp(// Union
namespace ns1 { namespace ns1 {
union MyUnion { int x; int y; }; union MyUnion { int x; int y; };
} // namespace ns1 } // namespace ns1
int main() { int main() {
ns1::My^Union Params; ns1::[[My^Union]] Params;
} }
)cpp", )cpp",
"text[Declared in]code[ns1]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "MyUnion";
"union MyUnion {}\n" HI.Kind = index::SymbolKind::Union;
"]", HI.NamespaceScope = "ns1::";
}, HI.Definition = "union MyUnion {}";
}},
{ {
R"cpp(// Function definition via pointer R"cpp(// Function definition via pointer
int foo(int) {} void foo(int) {}
int main() { int main() {
auto *X = &^foo; auto *X = &^[[foo]];
} }
)cpp", )cpp",
"text[Declared in]code[global namespace]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "foo";
"int foo(int)\n" HI.Kind = index::SymbolKind::Function;
"]\n" HI.NamespaceScope = "";
"text[Function definition via pointer]", HI.Type = "void (int)";
}, HI.Definition = "void foo(int)";
HI.Documentation = "Function definition via pointer";
HI.ReturnType = "void";
HI.Parameters = {
{std::string("int"), llvm::None, llvm::None},
};
}},
{ {
R"cpp(// Function declaration via call R"cpp(// Function declaration via call
int foo(int); int foo(int);
int main() { int main() {
return ^foo(42); return ^[[foo]](42);
} }
)cpp", )cpp",
"text[Declared in]code[global namespace]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "foo";
"int foo(int)\n" HI.Kind = index::SymbolKind::Function;
"]\n" HI.NamespaceScope = "";
"text[Function declaration via call]", HI.Type = "int (int)";
}, HI.Definition = "int foo(int)";
HI.Documentation = "Function declaration via call";
HI.ReturnType = "int";
HI.Parameters = {
{std::string("int"), llvm::None, llvm::None},
};
}},
{ {
R"cpp(// Field R"cpp(// Field
struct Foo { int x; }; struct Foo { int x; };
int main() { int main() {
Foo bar; Foo bar;
bar.^x; (void)bar.^[[x]];
} }
)cpp", )cpp",
"text[Declared in]code[Foo]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "x";
"int x\n" HI.Kind = index::SymbolKind::Field;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "Foo::";
HI.Type = "int";
HI.Definition = "int x";
}},
{ {
R"cpp(// Field with initialization R"cpp(// Field with initialization
struct Foo { int x = 5; }; struct Foo { int x = 5; };
int main() { int main() {
Foo bar; Foo bar;
bar.^x; (void)bar.^[[x]];
} }
)cpp", )cpp",
"text[Declared in]code[Foo]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "x";
"int x = 5\n" HI.Kind = index::SymbolKind::Field;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "Foo::";
HI.Type = "int";
HI.Definition = "int x = 5";
}},
{ {
R"cpp(// Static field R"cpp(// Static field
struct Foo { static int x; }; struct Foo { static int x; };
int main() { int main() {
Foo::^x; (void)Foo::^[[x]];
} }
)cpp", )cpp",
"text[Declared in]code[Foo]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "x";
"static int x\n" HI.Kind = index::SymbolKind::StaticProperty;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "Foo::";
HI.Type = "int";
HI.Definition = "static int x";
}},
{ {
R"cpp(// Field, member initializer R"cpp(// Field, member initializer
struct Foo { struct Foo {
int x; int x;
Foo() : ^x(0) {} Foo() : ^[[x]](0) {}
}; };
)cpp", )cpp",
"text[Declared in]code[Foo]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "x";
"int x\n" HI.Kind = index::SymbolKind::Field;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "Foo::";
HI.Type = "int";
HI.Definition = "int x";
}},
{ {
R"cpp(// Field, GNU old-style field designator R"cpp(// Field, GNU old-style field designator
struct Foo { int x; }; struct Foo { int x; };
int main() { int main() {
Foo bar = { ^x : 1 }; Foo bar = { ^[[x]] : 1 };
} }
)cpp", )cpp",
"text[Declared in]code[Foo]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "x";
"int x\n" HI.Kind = index::SymbolKind::Field;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "Foo::";
HI.Type = "int";
HI.Definition = "int x";
HI.Value = "{1}";
}},
{ {
R"cpp(// Field, field designator R"cpp(// Field, field designator
struct Foo { int x; }; struct Foo { int x; };
int main() { int main() {
Foo bar = { .^x = 2 }; Foo bar = { .^[[x]] = 2 };
} }
)cpp", )cpp",
"text[Declared in]code[Foo]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "x";
"int x\n" HI.Kind = index::SymbolKind::Field;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "Foo::";
HI.Type = "int";
HI.Definition = "int x";
HI.Value = "{2}";
}},
{ {
R"cpp(// Method call R"cpp(// Method call
struct Foo { int x(); }; struct Foo { int x(); };
int main() { int main() {
Foo bar; Foo bar;
bar.^x(); bar.^[[x]]();
} }
)cpp", )cpp",
"text[Declared in]code[Foo]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "x";
"int x()\n" HI.Kind = index::SymbolKind::InstanceMethod;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "Foo::";
HI.Type = "int ()";
HI.Definition = "int x()";
HI.ReturnType = "int";
HI.Parameters = std::vector<HoverInfo::Param>{};
}},
{ {
R"cpp(// Static method call R"cpp(// Static method call
struct Foo { static int x(); }; struct Foo { static int x(); };
int main() { int main() {
Foo::^x(); Foo::^[[x]]();
} }
)cpp", )cpp",
"text[Declared in]code[Foo]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "x";
"static int x()\n" HI.Kind = index::SymbolKind::StaticMethod;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "Foo::";
HI.Type = "int ()";
HI.Definition = "static int x()";
HI.ReturnType = "int";
HI.Parameters = std::vector<HoverInfo::Param>{};
}},
{ {
R"cpp(// Typedef R"cpp(// Typedef
typedef int Foo; typedef int Foo;
int main() { int main() {
^Foo bar; ^[[Foo]] bar;
} }
)cpp", )cpp",
"text[Declared in]code[global namespace]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "Foo";
"typedef int Foo\n" HI.Kind = index::SymbolKind::TypeAlias;
"]\n" HI.NamespaceScope = "";
"text[Typedef]", HI.Definition = "typedef int Foo";
}, HI.Documentation = "Typedef";
// FIXME: Maybe put underlying type into HI.Type for aliases?
}},
{ {
R"cpp(// Typedef with embedded definition R"cpp(// Typedef with embedded definition
typedef struct Bar {} Foo; typedef struct Bar {} Foo;
int main() { int main() {
^Foo bar; ^[[Foo]] bar;
} }
)cpp", )cpp",
"text[Declared in]code[global namespace]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "Foo";
"typedef struct Bar Foo\n" HI.Kind = index::SymbolKind::TypeAlias;
"]\n" HI.NamespaceScope = "";
"text[Typedef with embedded definition]", HI.Definition = "typedef struct Bar Foo";
}, HI.Documentation = "Typedef with embedded definition";
}},
{ {
R"cpp(// Namespace R"cpp(// Namespace
namespace ns { namespace ns {
struct Foo { static void bar(); } struct Foo { static void bar(); };
} // namespace ns } // namespace ns
int main() { ^ns::Foo::bar(); } int main() { ^[[ns]]::Foo::bar(); }
)cpp", )cpp",
"text[Declared in]code[global namespace]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "ns";
"namespace ns {}\n" HI.Kind = index::SymbolKind::Namespace;
"]", HI.NamespaceScope = "";
}, HI.Definition = "namespace ns {}";
}},
{ {
R"cpp(// Anonymous namespace R"cpp(// Anonymous namespace
namespace ns { namespace ns {
namespace { namespace {
int foo; int foo;
} // anonymous namespace } // anonymous namespace
} // namespace ns } // namespace ns
int main() { ns::f^oo++; } int main() { ns::[[f^oo]]++; }
)cpp", )cpp",
"text[Declared in]code[ns::(anonymous)]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "foo";
"int foo\n" HI.Kind = index::SymbolKind::Variable;
"]", HI.NamespaceScope = "ns::(anonymous)::";
}, HI.Type = "int";
HI.Definition = "int foo";
}},
{ {
R"cpp(// Macro R"cpp(// Macro
#define MACRO 0 #define MACRO 0
#define MACRO 1 int main() { return ^[[MACRO]]; }
int main() { return ^MACRO; } )cpp",
#define MACRO 2 [](HoverInfo &HI) {
#undef macro HI.Name = "MACRO";
)cpp", HI.Kind = index::SymbolKind::Macro;
"codeblock(cpp) [\n" HI.Definition = "#define MACRO 0";
"#define MACRO 1\n" }},
"]",
},
{ {
R"cpp(// Macro R"cpp(// Macro
#define MACRO 0 #define MACRO 0
#define MACRO2 ^MACRO #define MACRO2 ^[[MACRO]]
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) {
"#define MACRO 0\n" HI.Name = "MACRO";
"]", HI.Kind = index::SymbolKind::Macro;
}, HI.Definition = "#define MACRO 0";
}},
{ {
R"cpp(// Macro R"cpp(// Macro
#define MACRO {\ #define MACRO {\
return 0;\ return 0;\
} }
int main() ^MACRO int main() ^[[MACRO]]
)cpp", )cpp",
R"cpp(codeblock(cpp) [ [](HoverInfo &HI) {
#define MACRO \ HI.Name = "MACRO";
{ return 0; } HI.Kind = index::SymbolKind::Macro;
])cpp", HI.Definition =
}, R"cpp(#define MACRO \
{ return 0; })cpp";
}},
{ {
R"cpp(// Forward class declaration R"cpp(// Forward class declaration
class Foo; class Foo;
class Foo {}; class Foo {};
F^oo* foo(); [[F^oo]]* foo();
)cpp", )cpp",
"text[Declared in]code[global namespace]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "Foo";
"class Foo {}\n" HI.Kind = index::SymbolKind::Class;
"]\n" HI.NamespaceScope = "";
"text[Forward class declaration]", HI.Definition = "class Foo {}";
}, HI.Documentation = "Forward class declaration";
}},
{ {
R"cpp(// Function declaration R"cpp(// Function declaration
void foo(); void foo();
void g() { f^oo(); } void g() { [[f^oo]](); }
void foo() {} void foo() {}
)cpp", )cpp",
"text[Declared in]code[global namespace]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "foo";
"void foo()\n" HI.Kind = index::SymbolKind::Function;
"]\n" HI.NamespaceScope = "";
"text[Function declaration]", HI.Type = "void ()";
}, HI.Definition = "void foo()";
HI.Documentation = "Function declaration";
HI.ReturnType = "void";
HI.Parameters = std::vector<HoverInfo::Param>{};
}},
{ {
R"cpp(// Enum declaration R"cpp(// Enum declaration
enum Hello { enum Hello {
ONE, TWO, THREE, ONE, TWO, THREE,
}; };
void foo() { void foo() {
Hel^lo hello = ONE; [[Hel^lo]] hello = ONE;
} }
)cpp", )cpp",
"text[Declared in]code[global namespace]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "Hello";
"enum Hello {}\n" HI.Kind = index::SymbolKind::Enum;
"]\n" HI.NamespaceScope = "";
"text[Enum declaration]", HI.Definition = "enum Hello {}";
}, HI.Documentation = "Enum declaration";
}},
{ {
R"cpp(// Enumerator R"cpp(// Enumerator
enum Hello { enum Hello {
ONE, TWO, THREE, ONE, TWO, THREE,
}; };
void foo() { void foo() {
Hello hello = O^NE; Hello hello = [[O^NE]];
} }
)cpp", )cpp",
"text[Declared in]code[Hello]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "ONE";
"ONE\n" HI.Kind = index::SymbolKind::EnumConstant;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "Hello::";
HI.Type = "enum Hello";
HI.Definition = "ONE";
HI.Value = "0";
}},
{ {
R"cpp(// Enumerator in anonymous enum R"cpp(// Enumerator in anonymous enum
enum { enum {
ONE, TWO, THREE, ONE, TWO, THREE,
}; };
void foo() { void foo() {
int hello = O^NE; int hello = [[O^NE]];
} }
)cpp", )cpp",
"text[Declared in]code[global namespace]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "ONE";
"ONE\n" HI.Kind = index::SymbolKind::EnumConstant;
"]", HI.NamespaceScope = "";
}, // FIXME: This should be `(anon enum)::`
HI.LocalScope = "";
HI.Type = "enum (anonymous)";
HI.Definition = "ONE";
HI.Value = "0";
}},
{ {
R"cpp(// Global variable R"cpp(// Global variable
static int hey = 10; static int hey = 10;
void foo() { void foo() {
he^y++; [[he^y]]++;
} }
)cpp", )cpp",
"text[Declared in]code[global namespace]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "hey";
"static int hey = 10\n" HI.Kind = index::SymbolKind::Variable;
"]\n" HI.NamespaceScope = "";
"text[Global variable]", HI.Type = "int";
}, HI.Definition = "static int hey = 10";
HI.Documentation = "Global variable";
// FIXME: Value shouldn't be set in this case
HI.Value = "10";
}},
{ {
R"cpp(// Global variable in namespace R"cpp(// Global variable in namespace
namespace ns1 { namespace ns1 {
static int hey = 10; static int hey = 10;
} }
void foo() { void foo() {
ns1::he^y++; ns1::[[he^y]]++;
} }
)cpp", )cpp",
"text[Declared in]code[ns1]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "hey";
"static int hey = 10\n" HI.Kind = index::SymbolKind::Variable;
"]", HI.NamespaceScope = "ns1::";
}, HI.Type = "int";
HI.Definition = "static int hey = 10";
HI.Value = "10";
}},
{ {
R"cpp(// Field in anonymous struct R"cpp(// Field in anonymous struct
static struct { static struct {
int hello; int hello;
} s; } s;
void foo() { void foo() {
s.he^llo++; s.[[he^llo]]++;
} }
)cpp", )cpp",
"text[Declared in]code[(anonymous struct)]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "hello";
"int hello\n" HI.Kind = index::SymbolKind::Field;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "(anonymous struct)::";
HI.Type = "int";
HI.Definition = "int hello";
}},
{ {
R"cpp(// Templated function R"cpp(// Templated function
template <typename T> template <typename T>
T foo() { T foo() {
return 17; return 17;
} }
void g() { auto x = f^oo<int>(); } void g() { auto x = [[f^oo]]<int>(); }
)cpp", )cpp",
"text[Declared in]code[global namespace]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "foo";
"template <typename T> T foo()\n" HI.Kind = index::SymbolKind::Function;
"]\n" HI.NamespaceScope = "";
"text[Templated function]", HI.Type = "T ()";
}, HI.Definition = "template <typename T> T foo()";
HI.Documentation = "Templated function";
HI.ReturnType = "T";
HI.Parameters = std::vector<HoverInfo::Param>{};
HI.TemplateParameters = {
{std::string("typename"), std::string("T"), llvm::None},
};
}},
{ {
R"cpp(// Anonymous union R"cpp(// Anonymous union
struct outer { struct outer {
union { union {
int abc, def; int abc, def;
} v; } v;
}; };
void g() { struct outer o; o.v.d^ef++; } void g() { struct outer o; o.v.[[d^ef]]++; }
)cpp", )cpp",
"text[Declared in]code[outer::(anonymous union)]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "def";
"int def\n" HI.Kind = index::SymbolKind::Field;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "outer::(anonymous union)::";
HI.Type = "int";
HI.Definition = "int def";
}},
{ {
R"cpp(// documentation from index R"cpp(// documentation from index
int nextSymbolIsAForwardDeclFromIndexWithNoLocalDocs; int nextSymbolIsAForwardDeclFromIndexWithNoLocalDocs;
void indexSymbol(); void indexSymbol();
void g() { ind^exSymbol(); } void g() { [[ind^exSymbol]](); }
)cpp",
"text[Declared in]code[global namespace]\n"
"codeblock(cpp) [\n"
"void indexSymbol()\n"
"]\n"
"text[comment from index]",
},
{
R"cpp(// Nothing
void foo() {
^
}
)cpp", )cpp",
"", [](HoverInfo &HI) {
}, HI.Name = "indexSymbol";
HI.Kind = index::SymbolKind::Function;
HI.NamespaceScope = "";
HI.Type = "void ()";
HI.Definition = "void indexSymbol()";
HI.ReturnType = "void";
HI.Parameters = std::vector<HoverInfo::Param>{};
HI.Documentation = "comment from index";
}},
{ {
R"cpp(// Simple initialization with auto R"cpp(// Simple initialization with auto
void foo() { void foo() {
^auto i = 1; ^[[auto]] i = 1;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) {
"int\n" HI.Name = "int";
"]", // FIXME: Should be Builtin/Integral.
}, HI.Kind = index::SymbolKind::Unknown;
}},
{ {
R"cpp(// Simple initialization with const auto R"cpp(// Simple initialization with const auto
void foo() { void foo() {
const ^auto i = 1; const ^[[auto]] i = 1;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int"; }},
"int\n"
"]",
},
{ {
R"cpp(// Simple initialization with const auto& R"cpp(// Simple initialization with const auto&
void foo() { void foo() {
const ^auto& i = 1; const ^[[auto]]& i = 1;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int"; }},
"int\n"
"]",
},
{ {
R"cpp(// Simple initialization with auto& R"cpp(// Simple initialization with auto&
void foo() { void foo() {
^auto& i = 1; int x;
^[[auto]]& i = x;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int"; }},
"int\n"
"]",
},
{ {
R"cpp(// Simple initialization with auto* R"cpp(// Simple initialization with auto*
void foo() { void foo() {
int a = 1; int a = 1;
^auto* i = &a; ^[[auto]]* i = &a;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int"; }},
"int\n"
"]",
},
{ {
R"cpp(// Auto with initializer list. R"cpp(// Auto with initializer list.
namespace std namespace std
{ {
template<class _E> template<class _E>
class initializer_list {}; class initializer_list {};
} }
void foo() { void foo() {
^auto i = {1,2}; ^[[auto]] i = {1,2};
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) {
"class std::initializer_list<int>\n" HI.Name = "class std::initializer_list<int>";
"]", HI.Kind = index::SymbolKind::Class;
}, }},
{ {
R"cpp(// User defined conversion to auto R"cpp(// User defined conversion to auto
struct Bar { struct Bar {
operator ^auto() const { return 10; } operator ^[[auto]]() const { return 10; }
}; };
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int"; }},
"int\n"
"]",
},
{ {
R"cpp(// Simple initialization with decltype(auto) R"cpp(// Simple initialization with decltype(auto)
void foo() { void foo() {
^decltype(auto) i = 1; ^[[decltype]](auto) i = 1;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int"; }},
"int\n"
"]",
},
{ {
R"cpp(// Simple initialization with const decltype(auto) R"cpp(// Simple initialization with const decltype(auto)
void foo() { void foo() {
const int j = 0; const int j = 0;
^decltype(auto) i = j; ^[[decltype]](auto) i = j;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "const int"; }},
"const int\n"
"]",
},
{ {
R"cpp(// Simple initialization with const& decltype(auto) R"cpp(// Simple initialization with const& decltype(auto)
void foo() { void foo() {
int k = 0; int k = 0;
const int& j = k; const int& j = k;
^decltype(auto) i = j; ^[[decltype]](auto) i = j;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "const int &"; }},
"const int &\n"
"]",
},
{ {
R"cpp(// Simple initialization with & decltype(auto) R"cpp(// Simple initialization with & decltype(auto)
void foo() { void foo() {
int k = 0; int k = 0;
int& j = k; int& j = k;
^decltype(auto) i = j; ^[[decltype]](auto) i = j;
}
)cpp",
"codeblock(cpp) [\n"
"int &\n"
"]",
},
{
R"cpp(// decltype with initializer list: nothing
namespace std
{
template<class _E>
class initializer_list {};
}
void foo() {
^decltype(auto) i = {1,2};
} }
)cpp", )cpp",
"", [](HoverInfo &HI) { HI.Name = "int &"; }},
},
{ {
R"cpp(// simple trailing return type R"cpp(// simple trailing return type
^auto main() -> int { ^[[auto]] main() -> int {
return 0; return 0;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int"; }},
"int\n"
"]",
},
{ {
R"cpp(// auto function return with trailing type R"cpp(// auto function return with trailing type
struct Bar {}; struct Bar {};
^auto test() -> decltype(Bar()) { ^[[auto]] test() -> decltype(Bar()) {
return Bar(); return Bar();
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) {
"struct Bar\n" HI.Name = "struct Bar";
"]", HI.Kind = index::SymbolKind::Struct;
}, }},
{ {
R"cpp(// trailing return type R"cpp(// trailing return type
struct Bar {}; struct Bar {};
auto test() -> ^decltype(Bar()) { auto test() -> ^[[decltype]](Bar()) {
return Bar(); return Bar();
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) {
"struct Bar\n" HI.Name = "struct Bar";
"]", HI.Kind = index::SymbolKind::Struct;
}, }},
{ {
R"cpp(// auto in function return R"cpp(// auto in function return
struct Bar {}; struct Bar {};
^auto test() { ^[[auto]] test() {
return Bar(); return Bar();
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) {
"struct Bar\n" HI.Name = "struct Bar";
"]", HI.Kind = index::SymbolKind::Struct;
}, }},
{ {
R"cpp(// auto& in function return R"cpp(// auto& in function return
struct Bar {}; struct Bar {};
^auto& test() { ^[[auto]]& test() {
return Bar(); static Bar x;
return x;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) {
"struct Bar\n" HI.Name = "struct Bar";
"]", HI.Kind = index::SymbolKind::Struct;
}, }},
{ {
R"cpp(// auto* in function return R"cpp(// auto* in function return
struct Bar {}; struct Bar {};
^auto* test() { ^[[auto]]* test() {
Bar* bar; Bar* bar;
return bar; return bar;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) {
"struct Bar\n" HI.Name = "struct Bar";
"]", HI.Kind = index::SymbolKind::Struct;
}, }},
{ {
R"cpp(// const auto& in function return R"cpp(// const auto& in function return
struct Bar {}; struct Bar {};
const ^auto& test() { const ^[[auto]]& test() {
return Bar(); static Bar x;
return x;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) {
"struct Bar\n" HI.Name = "struct Bar";
"]", HI.Kind = index::SymbolKind::Struct;
}, }},
{ {
R"cpp(// decltype(auto) in function return R"cpp(// decltype(auto) in function return
struct Bar {}; struct Bar {};
^decltype(auto) test() { ^[[decltype]](auto) test() {
return Bar(); return Bar();
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) {
"struct Bar\n" HI.Name = "struct Bar";
"]", HI.Kind = index::SymbolKind::Struct;
}, }},
{ {
R"cpp(// decltype(auto) reference in function return R"cpp(// decltype(auto) reference in function return
struct Bar {}; ^[[decltype]](auto) test() {
^decltype(auto) test() { static int a;
int a;
return (a); return (a);
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int &"; }},
"int &\n"
"]",
},
{ {
R"cpp(// decltype lvalue reference R"cpp(// decltype lvalue reference
void foo() { void foo() {
int I = 0; int I = 0;
^decltype(I) J = I; ^[[decltype]](I) J = I;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int"; }},
"int\n"
"]",
},
{ {
R"cpp(// decltype lvalue reference R"cpp(// decltype lvalue reference
void foo() { void foo() {
int I= 0; int I= 0;
int &K = I; int &K = I;
^decltype(K) J = I; ^[[decltype]](K) J = I;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int &"; }},
"int &\n"
"]",
},
{ {
R"cpp(// decltype lvalue reference parenthesis R"cpp(// decltype lvalue reference parenthesis
void foo() { void foo() {
int I = 0; int I = 0;
^decltype((I)) J = I; ^[[decltype]]((I)) J = I;
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int &"; }},
"int &\n"
"]",
},
{ {
R"cpp(// decltype rvalue reference R"cpp(// decltype rvalue reference
void foo() { void foo() {
int I = 0; int I = 0;
^decltype(static_cast<int&&>(I)) J = static_cast<int&&>(I); ^[[decltype]](static_cast<int&&>(I)) J = static_cast<int&&>(I);
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int &&"; }},
"int &&\n"
"]",
},
{ {
R"cpp(// decltype rvalue reference function call R"cpp(// decltype rvalue reference function call
int && bar(); int && bar();
void foo() { void foo() {
int I = 0; int I = 0;
^decltype(bar()) J = bar(); ^[[decltype]](bar()) J = bar();
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int &&"; }},
"int &&\n"
"]",
},
{ {
R"cpp(// decltype of function with trailing return type. R"cpp(// decltype of function with trailing return type.
struct Bar {}; struct Bar {};
auto test() -> decltype(Bar()) { auto test() -> decltype(Bar()) {
return Bar(); return Bar();
} }
void foo() { void foo() {
^decltype(test()) i = test(); ^[[decltype]](test()) i = test();
} }
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) {
"struct Bar\n" HI.Name = "struct Bar";
"]", HI.Kind = index::SymbolKind::Struct;
}, }},
{ {
R"cpp(// decltype of var with decltype. R"cpp(// decltype of var with decltype.
void foo() { void foo() {
int I = 0; int I = 0;
decltype(I) J = I; decltype(I) J = I;
^decltype(J) K = J; ^[[decltype]](J) K = J;
}
)cpp",
"codeblock(cpp) [\n"
"int\n"
"]",
},
{
R"cpp(// structured binding. Not supported yet
struct Bar {};
void foo() {
Bar a[2];
^auto [x,y] = a;
}
)cpp",
"",
},
{
R"cpp(// Template auto parameter. Nothing (Not useful).
template<^auto T>
void func() {
}
void foo() {
func<1>();
} }
)cpp", )cpp",
"", [](HoverInfo &HI) { HI.Name = "int"; }},
},
{ {
R"cpp(// More compilcated structured types. R"cpp(// More compilcated structured types.
int bar(); int bar();
^auto (*foo)() = bar; ^[[auto]] (*foo)() = bar;
)cpp", )cpp",
"codeblock(cpp) [\n" [](HoverInfo &HI) { HI.Name = "int"; }},
"int\n"
"]",
},
{ {
R"cpp(// Should not crash when evaluating the initializer. R"cpp(// Should not crash when evaluating the initializer.
struct Test {}; struct Test {};
void test() { Test && te^st = {}; } void test() { Test && [[te^st]] = {}; }
)cpp", )cpp",
"text[Declared in]code[test]\n" [](HoverInfo &HI) {
"codeblock(cpp) [\n" HI.Name = "test";
"struct Test &&test = {}\n" HI.Kind = index::SymbolKind::Variable;
"]", HI.NamespaceScope = "";
}, HI.LocalScope = "test::";
HI.Type = "struct Test &&";
HI.Definition = "struct Test &&test = {}";
HI.Value = "{}";
}},
}; };
// Create a tiny index, so tests above can verify documentation is fetched. // Create a tiny index, so tests above can verify documentation is fetched.
Symbol IndexSym = func("indexSymbol"); Symbol IndexSym = func("indexSymbol");
IndexSym.Documentation = "comment from index"; IndexSym.Documentation = "comment from index";
SymbolSlab::Builder Symbols; SymbolSlab::Builder Symbols;
Symbols.insert(IndexSym); Symbols.insert(IndexSym);
auto Index = auto Index =
MemIndex::build(std::move(Symbols).build(), RefSlab(), RelationSlab()); MemIndex::build(std::move(Symbols).build(), RefSlab(), RelationSlab());
for (const OneTest &Test : Tests) { for (const auto &Case : Cases) {
Annotations T(Test.Input); SCOPED_TRACE(Case.Code);
Annotations T(Case.Code);
TestTU TU = TestTU::withCode(T.code()); TestTU TU = TestTU::withCode(T.code());
TU.ExtraArgs.push_back("-std=c++17"); TU.ExtraArgs.push_back("-std=c++17");
TU.ExtraArgs.push_back("-Wno-gnu-designator");
auto AST = TU.build(); auto AST = TU.build();
if (auto H = for (const auto &D : AST.getDiagnostics())
getHover(AST, T.point(), format::getLLVMStyle(), Index.get())) { ADD_FAILURE() << D;
EXPECT_NE("", Test.ExpectedHover) << Test.Input; ASSERT_TRUE(AST.getDiagnostics().empty());
EXPECT_EQ(H->present().renderForTests(), Test.ExpectedHover.str())
<< Test.Input; auto H = getHover(AST, T.point(), format::getLLVMStyle(), Index.get());
} else ASSERT_TRUE(H);
EXPECT_EQ("", Test.ExpectedHover.str()) << Test.Input; HoverInfo Expected;
Expected.SymRange = T.range();
Case.ExpectedBuilder(Expected);
EXPECT_EQ(H->NamespaceScope, Expected.NamespaceScope);
EXPECT_EQ(H->LocalScope, Expected.LocalScope);
EXPECT_EQ(H->Name, Expected.Name);
EXPECT_EQ(H->Kind, Expected.Kind);
EXPECT_EQ(H->Documentation, Expected.Documentation);
EXPECT_EQ(H->Definition, Expected.Definition);
EXPECT_EQ(H->Type, Expected.Type);
EXPECT_EQ(H->ReturnType, Expected.ReturnType);
EXPECT_EQ(H->Parameters, Expected.Parameters);
EXPECT_EQ(H->TemplateParameters, Expected.TemplateParameters);
EXPECT_EQ(H->SymRange, Expected.SymRange);
EXPECT_EQ(H->Value, Expected.Value);
} }
} }
} // namespace } // namespace
} // namespace clangd } // namespace clangd
} // namespace clang } // namespace clang