| blob | 91060a517de5304e7f047403674dab41690c24d5 |
1 //===-- HoverTests.cpp ----------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
24 #include <functional>
25 #include <optional>
26 #include <string>
27 #include <vector>
37 }
44 // Global scope.
46 // Best foo ever.
47 void [[fo^o]]() {}
58 }},
59 // Inside namespace
61 namespace ns1 { namespace ns2 {
62 /// Best foo ever.
63 void [[fo^o]]() {}
64 }}
75 }},
76 // Field
78 namespace ns1 { namespace ns2 {
79 class Foo {
80 char [[b^ar]];
81 double y[2];
82 };
83 }}
96 }},
97 // Union field
99 union Foo {
100 char [[b^ar]];
101 double y[2];
102 };
114 }},
115 // Bitfield
117 struct Foo {
118 int [[^x]] : 1;
119 int y : 1;
120 };
132 }},
133 // Local to class method.
135 namespace ns1 { namespace ns2 {
136 struct Foo {
137 void foo() {
138 int [[b^ar]];
139 }
140 };
141 }}
150 }},
151 // Predefined variable
153 void foo() {
154 [[__f^unc__]];
155 }
164 }},
165 // Predefined variable (dependent)
167 template<int> void foo() {
168 [[__f^unc__]];
169 }
177 }},
178 // Anon namespace and local scope.
180 namespace ns1 { namespace {
181 struct {
182 char [[b^ar]];
183 } T;
184 }}
196 }},
197 // Struct definition shows size.
199 struct [[^X]]{};
207 }},
208 // Variable with template type
210 template <typename T, class... Ts> class Foo { public: Foo(int); };
211 Foo<int, char, bool> [[fo^o]] = Foo<int, char, bool>(5);
219 }},
220 // Implicit template instantiation
222 template <typename T> class vector{};
223 [[vec^tor]]<int> foo;
230 }},
231 // Class template
233 template <template<typename, bool...> class C,
234 typename = char,
235 int = 0,
236 bool Q = false,
237 class... Ts> class Foo final {};
238 template <template<typename, bool...> class T>
239 [[F^oo]]<T> foo;
246 R"cpp(template <template <typename, bool...> class C, typename = char, int = 0,
247 bool Q = false, class... Ts>
257 };
258 }},
259 // Function template
261 template <template<typename, bool...> class C,
262 typename = char,
263 int = 0,
264 bool Q = false,
265 class... Ts> void foo();
266 template<typename, bool...> class Foo;
268 void bar() {
269 [[fo^o]]<Foo>();
270 }
280 }},
281 // Function decl
283 template<typename, bool...> class Foo {};
284 Foo<bool, true, false> foo(int, bool T = false);
286 void bar() {
287 [[fo^o]](3);
288 }
300 };
301 }},
302 // Pointers to lambdas
304 void foo() {
305 auto lamb = [](int T, bool B) -> bool { return T && B; };
306 auto *b = &lamb;
307 auto *[[^c]] = &b;
308 }
321 };
323 }},
324 // Lambda parameter with decltype reference
326 auto lamb = [](int T, bool B) -> bool { return T && B; };
327 void foo(decltype(lamb)& bar) {
328 [[ba^r]](0, false);
329 }
342 };
344 }},
345 // Lambda parameter with decltype
347 auto lamb = [](int T, bool B) -> bool { return T && B; };
348 void foo(decltype(lamb) bar) {
349 [[ba^r]](0, false);
350 }
363 };
366 }},
367 // Lambda variable
369 void foo() {
370 int bar = 5;
371 auto lamb = [&bar](int T, bool B) -> bool { return T && B && bar; };
372 bool res = [[lam^b]](bar, false);
373 }
386 };
388 }},
389 // Local variable in lambda
391 void foo() {
392 auto lamb = []{int [[te^st]];};
393 }
402 }},
403 // Partially-specialized class template. (formerly type-parameter-0-0)
405 template <typename T> class X;
406 template <typename T> class [[^X]]<T*> {};
413 }},
414 // Constructor of partially-specialized class template
416 template<typename, typename=void> struct X;
417 template<typename T> struct X<T*>{ [[^X]](); };
427 }},
437 }},
447 }},
454 }},
456 // auto on structured bindings
458 void foo() {
459 struct S { int x; float y; };
460 [[au^to]] [x, y] = S();
461 }
467 }},
468 // undeduced auto
470 template<typename T>
471 void foo() {
472 [[au^to]] x = T{};
473 }
479 }},
480 // constrained auto
482 template <class T> concept F = true;
483 F [[au^to]] x = 1;
489 }},
490 // auto on lambda
492 void foo() {
493 [[au^to]] lamb = []{};
494 }
500 }},
501 // auto on template instantiation
503 template<typename T> class Foo{};
504 void foo() {
505 [[au^to]] x = Foo<int>();
506 }
512 }},
513 // auto on specialized template
515 template<typename T> class Foo{};
516 template<> class Foo<int>{};
517 void foo() {
518 [[au^to]] x = Foo<int>();
519 }
525 }},
527 // empty macro
529 #define MACRO
530 [[MAC^RO]]
536 }},
538 // object-like macro
540 #define MACRO 41
541 int x = [[MAC^RO]];
551 }},
553 // function-like macro
555 // Best MACRO ever.
556 #define MACRO(x,y,z) void foo(x, y, z)
557 [[MAC^RO]](int, double d, bool z = false);
565 }},
567 // nested macro
569 #define STRINGIFY_AUX(s) #s
570 #define STRINGIFY(s) STRINGIFY_AUX(s)
571 #define DECL_STR(NAME, VALUE) const char *v_##NAME = STRINGIFY(VALUE)
572 #define FOO 41
574 [[DECL^_STR]](foo, FOO);
584 }},
586 // constexprs
588 constexpr int add(int a, int b) { return a + b; }
589 int [[b^ar]] = add(1, 2);
598 }},
600 int [[b^ar]] = sizeof(char);
609 }},
611 template<int a, int b> struct Add {
612 static constexpr int result = a + b;
613 };
614 int [[ba^r]] = Add<1, 2>::result;
623 }},
625 enum Color { RED = -123, GREEN = 5, };
626 Color x = [[GR^EEN]];
636 }},
638 enum Color { RED = -123, GREEN = 5, };
639 Color x = RED;
640 Color y = [[^x]];
649 }},
651 template<int a, int b> struct Add {
652 static constexpr int result = a + b;
653 };
654 int bar = Add<1, 2>::[[resu^lt]];
665 }},
667 using my_int = int;
668 constexpr my_int answer() { return 40 + 2; }
669 int x = [[ans^wer]]();
680 }},
691 }},
693 template <typename T>
694 struct Tmpl {
695 Tmpl(int name);
696 };
698 template <typename A>
699 void boom(int name) {
700 new Tmpl<A>([[na^me]]);
709 }},
710 {
711 R"cpp(// Should not print inline or anon namespaces.
712 namespace ns {
713 inline namespace in_ns {
714 namespace a {
715 namespace {
716 namespace b {
717 inline namespace in_ns2 {
718 class Foo {};
719 } // in_ns2
720 } // b
721 } // anon
722 } // a
723 } // in_ns
724 } // ns
725 void foo() {
726 ns::a::b::[[F^oo]] x;
727 (void)x;
728 }
735 }},
736 {
737 R"cpp(
738 template <typename T> class Foo {};
739 class X;
740 void foo() {
741 [[^auto]] x = Foo<X>();
742 }
748 }},
750 R"cpp(
751 // comment from primary
752 template <typename T> class Foo {};
753 // comment from specialization
754 template <typename T> class Foo<T*> {};
755 void foo() {
756 [[Fo^o]]<int*> *x = nullptr;
757 }
764 // FIXME: Maybe force instantiation to make use of real template
765 // pattern.
767 }},
769 R"cpp(
770 template <typename [[^T]] = int> void foo();
780 }},
782 R"cpp(
783 template <template<typename> class [[^T]]> void foo();
793 }},
795 R"cpp(
796 template <int [[^T]] = 5> void foo();
806 }},
809 R"cpp(
810 struct X { int Y; float [[^y]]() { return Y; } };
823 }},
825 R"cpp(
826 struct X { int Y; void [[^setY]](float v) { Y = v; } };
842 }},
844 R"cpp(
845 struct X { int Y; X& [[^setY]](float v) { Y = v; return *this; } };
861 }},
863 R"cpp(
864 namespace std { template<typename T> T&& move(T&& t); }
865 struct X { int Y; void [[^setY]](float v) { Y = std::move(v); } };
881 }},
883 R"cpp(
884 struct X { int x = 2; };
885 X ^[[x]];
893 }},
902 // Bindings are in theory public members of an anonymous struct.
904 }},
906 R"cpp(
907 void fun(int arg_a, int &arg_b) {};
908 void code() {
909 int a = 1, b = 2;
910 fun(a, [[^b]]);
911 }
925 }},
927 R"cpp(
928 struct Foo {
929 explicit Foo(int arg_a) {}
930 };
931 template<class T, class... Args>
932 T make(Args&&... args)
933 {
934 return T(args...);
935 }
937 void code() {
938 int a = 1;
939 auto foo = make<Foo>([[^a]]);
940 }
954 }},
955 {
956 R"cpp(
957 void foobar(const float &arg);
958 int main() {
959 int a = 0;
960 foobar([[^a]]);
961 }
975 }},
976 {
977 R"cpp(
978 struct Foo {
979 explicit Foo(const float& arg) {}
980 };
981 int main() {
982 int a = 0;
983 Foo foo([[^a]]);
984 }
998 }},
1000 R"cpp(
1001 void fun(int arg_a, const int &arg_b) {};
1002 void code() {
1003 int a = 1;
1004 fun(a, [[^2]]);
1005 }
1014 }},
1016 R"cpp(
1017 void fun(int arg_a, const int &arg_b) {};
1018 void code() {
1019 int a = 1;
1020 fun(a, 1 [[^+]] 2);
1021 }
1032 }},
1033 {
1034 R"cpp(
1035 int add(int lhs, int rhs);
1036 int main() {
1037 add(1 [[^+]] 2, 3);
1038 }
1049 }},
1050 {
1051 R"cpp(
1052 void foobar(const float &arg);
1053 int main() {
1054 foobar([[^0]]);
1055 }
1064 }},
1066 R"cpp(
1067 class C {
1068 public:
1069 void fun(int arg_a = 3, int arg_b = 4) {}
1070 };
1071 void code() {
1072 int a = 1, b = 2;
1073 C c;
1074 c.fun([[^a]], b);
1075 }
1090 }},
1091 {
1092 R"cpp(
1093 struct Foo {
1094 Foo(const int &);
1095 };
1096 void foo(Foo);
1097 void bar() {
1098 const int x = 0;
1099 foo([[^x]]);
1100 }
1113 }},
1115 R"cpp(
1116 // error-ok
1117 struct Foo {
1118 Bar [[x^x]];
1128 }},
1130 // error-ok
1131 struct Foo {
1132 Bar xx;
1133 int [[y^y]];
1143 }},
1145 R"cpp(
1146 struct Foo {
1147 int a[10];
1148 };
1149 constexpr Foo k2 = {
1150 ^[[{]]1} // FIXME: why the hover range is 1 character?
1151 };
1158 }},
1160 R"cpp(
1161 using m_int = int;
1163 template <int Size> m_int ^[[arr]][Size];
1172 }},
1174 R"cpp(
1175 using m_int = int;
1177 template <int Size> m_int arr[Size];
1179 template <> m_int ^[[arr]]<4>[4];
1187 }},
1189 R"cpp(
1190 template<typename T>
1191 struct TestHover {
1192 using Type = T;
1193 };
1195 void code() {
1196 TestHover<int>::Type ^[[a]];
1197 }
1206 }},
1208 R"cpp(
1209 template<typename T>
1210 void ^[[foo]](T arg) {}
1222 }},
1224 R"cpp(
1225 template<typename T>
1226 using ^[[alias]] = T;
1237 }},
1239 R"cpp(
1240 template<typename T>
1241 using A = T;
1243 template<typename T>
1244 using ^[[AA]] = A<T>;
1255 }},
1257 R"cpp(
1258 using m_int = int;
1260 m_int ^[[arr]][10];
1269 }},
1271 R"cpp(
1272 using m_int = int;
1274 extern m_int ^[[arr]][];
1283 }},
1285 R"cpp(
1286 using m_int = int;
1288 template<int Size>
1289 struct Test {
1290 m_int ^[[arr]][Size];
1291 };
1301 }},
1303 R"cpp(
1304 struct Foo {
1305 char x;
1306 char [[^y]] : 1;
1307 int z;
1308 };
1321 }}};
1328 // Types might be different depending on the target triplet, we chose a
1329 // fixed one to make sure tests passes on different platform.
1332 Config Cfg;
1338 HoverInfo Expected;
1359 }
1360 }
1368 void [[some^Global]]() {}
1372 void [[some^Global]]() {}
1376 void [[some^Global]]() {}
1392 }
1393 }
1397 class Base {};
1398 class Derived : public Base {};
1399 class CustomClass {
1400 public:
1401 CustomClass() {}
1402 CustomClass(const Base &x) {}
1403 CustomClass(int &x) {}
1404 CustomClass(float x) {}
1405 CustomClass(int x, int y) {}
1406 };
1408 void int_by_ref(int &x) {}
1409 void int_by_const_ref(const int &x) {}
1410 void int_by_value(int x) {}
1411 void base_by_ref(Base &x) {}
1412 void base_by_const_ref(const Base &x) {}
1413 void base_by_value(Base x) {}
1414 void float_by_value(float x) {}
1415 void custom_by_value(CustomClass x) {}
1417 void fun() {
1418 int int_x;
1419 int &int_ref = int_x;
1420 const int &int_const_ref = int_x;
1421 Base base;
1422 const Base &base_const_ref = base;
1423 Derived derived;
1424 float float_x;
1433 // Integer tests
1443 // Custom class tests
1452 // Custom class constructor tests
1457 // Converted tests
1466 };
1479 }
1480 }
1486 // FIXME: "decltype(auto)" should be a single hover
1488 // FIXME: not supported yet
1489 R"cpp(// Lambda auto parameter
1490 auto lamb = [](a^uto){};
1492 R"cpp(// non-named decls don't get hover. Don't crash!
1495 R"cpp(// non-evaluatable expr
1496 template <typename T> void foo() {
1497 (void)[[size^of]](T);
1499 R"cpp(// should not crash on invalid semantic form of init-list-expr.
1500 /*error-ok*/
1501 struct Foo {
1502 int xyz = 0;
1503 };
1504 class Bar {};
1505 constexpr Foo s = ^{
1506 .xyz = Bar(),
1507 };
1509 // literals
1516 };
1527 }
1528 }
1540 }},
1546 }},
1547 {
1548 R"cpp(// Local variable
1549 int main() {
1550 int bonjour;
1551 ^[[bonjour]] = 2;
1552 int test1 = bonjour;
1553 }
1562 }},
1563 {
1564 R"cpp(// Local variable in method
1565 struct s {
1566 void method() {
1567 int bonjour;
1568 ^[[bonjour]] = 2;
1569 }
1570 };
1579 }},
1580 {
1581 R"cpp(// Struct
1582 namespace ns1 {
1583 struct MyClass {};
1584 } // namespace ns1
1585 int main() {
1586 ns1::[[My^Class]]* Params;
1587 }
1594 }},
1595 {
1596 R"cpp(// Class
1597 namespace ns1 {
1598 class MyClass {};
1599 } // namespace ns1
1600 int main() {
1601 ns1::[[My^Class]]* Params;
1602 }
1609 }},
1610 {
1611 R"cpp(// Union
1612 namespace ns1 {
1613 union MyUnion { int x; int y; };
1614 } // namespace ns1
1615 int main() {
1616 ns1::[[My^Union]] Params;
1617 }
1624 }},
1625 {
1626 R"cpp(// Function definition via pointer
1627 void foo(int) {}
1628 int main() {
1629 auto *X = &^[[foo]];
1630 }
1642 };
1643 }},
1644 {
1645 R"cpp(// Function declaration via call
1646 int foo(int);
1647 int main() {
1648 return ^[[foo]](42);
1649 }
1661 };
1662 }},
1663 {
1664 R"cpp(// Field
1665 struct Foo { int x; };
1666 int main() {
1667 Foo bar;
1668 (void)bar.^[[x]];
1669 }
1678 }},
1679 {
1680 R"cpp(// Field with initialization
1681 struct Foo { int x = 5; };
1682 int main() {
1683 Foo bar;
1684 (void)bar.^[[x]];
1685 }
1694 }},
1695 {
1696 R"cpp(// Static field
1697 struct Foo { static int x; };
1698 int main() {
1699 (void)Foo::^[[x]];
1700 }
1709 }},
1710 {
1711 R"cpp(// Field, member initializer
1712 struct Foo {
1713 int x;
1714 Foo() : ^[[x]](0) {}
1715 };
1724 }},
1725 {
1726 R"cpp(// Field, GNU old-style field designator
1727 struct Foo { int x; };
1728 int main() {
1729 Foo bar = { ^[[x]] : 1 };
1730 }
1739 // FIXME: Initializer for x is a DesignatedInitListExpr, hence it is
1740 // of struct type and omitted.
1741 }},
1742 {
1743 R"cpp(// Field, field designator
1744 struct Foo { int x; int y; };
1745 int main() {
1746 Foo bar = { .^[[x]] = 2, .y = 2 };
1747 }
1756 }},
1757 {
1758 R"cpp(// Method call
1759 struct Foo { int x(); };
1760 int main() {
1761 Foo bar;
1762 bar.^[[x]]();
1763 }
1774 }},
1775 {
1776 R"cpp(// Static method call
1777 struct Foo { static int x(); };
1778 int main() {
1779 Foo::^[[x]]();
1780 }
1791 }},
1792 {
1793 R"cpp(// Typedef
1794 typedef int Foo;
1795 int main() {
1796 ^[[Foo]] bar;
1797 }
1806 }},
1807 {
1808 R"cpp(// Typedef with embedded definition
1809 typedef struct Bar {} Foo;
1810 int main() {
1811 ^[[Foo]] bar;
1812 }
1821 }},
1822 {
1823 R"cpp(// Namespace
1824 namespace ns {
1825 struct Foo { static void bar(); };
1826 } // namespace ns
1827 int main() { ^[[ns]]::Foo::bar(); }
1834 }},
1835 {
1836 R"cpp(// Anonymous namespace
1837 namespace ns {
1838 namespace {
1839 int foo;
1840 } // anonymous namespace
1841 } // namespace ns
1842 int main() { ns::[[f^oo]]++; }
1850 }},
1851 {
1852 R"cpp(// Function definition via using declaration
1853 namespace ns {
1854 void foo();
1855 }
1856 int main() {
1857 using ns::foo;
1858 ^[[foo]]();
1859 }
1870 }},
1871 {
1872 R"cpp( // using declaration and two possible function declarations
1873 namespace ns { void foo(int); void foo(char); }
1874 using ns::foo;
1875 template <typename T> void bar() { [[f^oo]](T{}); }
1882 }},
1883 {
1884 R"cpp(// Macro
1885 #define MACRO 0
1886 int main() { return ^[[MACRO]]; }
1896 }},
1897 {
1898 R"cpp(// Macro
1899 #define MACRO 0
1900 #define MACRO2 ^[[MACRO]]
1906 // NOTE MACRO doesn't have expansion since it technically isn't
1907 // expanded here
1908 }},
1909 {
1910 R"cpp(// Macro
1911 #define MACRO {\
1912 return 0;\
1913 }
1914 int main() ^[[MACRO]]
1920 R"cpp(#define MACRO \
1921 { return 0; }
1923 // Expands to
1925 }},
1926 {
1927 R"cpp(// Forward class declaration
1928 class Foo;
1929 class Foo {};
1930 [[F^oo]]* foo();
1938 }},
1939 {
1940 R"cpp(// Function declaration
1941 void foo();
1942 void g() { [[f^oo]](); }
1943 void foo() {}
1954 }},
1955 {
1956 R"cpp(// Enum declaration
1957 enum Hello {
1958 ONE, TWO, THREE,
1959 };
1960 void foo() {
1961 [[Hel^lo]] hello = ONE;
1962 }
1970 }},
1971 {
1972 R"cpp(// Enumerator
1973 enum Hello {
1974 ONE, TWO, THREE,
1975 };
1976 void foo() {
1977 Hello hello = [[O^NE]];
1978 }
1988 }},
1989 {
1990 R"cpp(// C++20's using enum
1991 enum class Hello {
1992 ONE, TWO, THREE,
1993 };
1994 void foo() {
1995 using enum Hello;
1996 Hello hello = [[O^NE]];
1997 }
2007 }},
2008 {
2009 R"cpp(// Enumerator in anonymous enum
2010 enum {
2011 ONE, TWO, THREE,
2012 };
2013 void foo() {
2014 int hello = [[O^NE]];
2015 }
2021 // FIXME: This should be `(anon enum)::`
2026 }},
2027 {
2028 R"cpp(// Global variable
2029 static int hey = 10;
2030 void foo() {
2031 [[he^y]]++;
2032 }
2041 // FIXME: Value shouldn't be set in this case
2043 }},
2044 {
2045 R"cpp(// Global variable in namespace
2046 namespace ns1 {
2047 static long long hey = -36637162602497;
2048 }
2049 void foo() {
2050 ns1::[[he^y]]++;
2051 }
2060 }},
2061 {
2062 R"cpp(// Field in anonymous struct
2063 static struct {
2064 int hello;
2065 } s;
2066 void foo() {
2067 s.[[he^llo]]++;
2068 }
2077 }},
2078 {
2079 R"cpp(// Templated function
2080 template <typename T>
2081 T foo() {
2082 return 17;
2083 }
2084 void g() { auto x = [[f^oo]]<int>(); }
2095 // FIXME: We should populate template parameters with arguments in
2096 // case of instantiations.
2097 }},
2098 {
2099 R"cpp(// Anonymous union
2100 struct outer {
2101 union {
2102 int abc, def;
2103 } v;
2104 };
2105 void g() { struct outer o; o.v.[[d^ef]]++; }
2114 }},
2115 {
2116 R"cpp(// documentation from index
2117 int nextSymbolIsAForwardDeclFromIndexWithNoLocalDocs;
2118 void indexSymbol();
2119 void g() { [[ind^exSymbol]](); }
2130 }},
2131 {
2132 R"cpp(// Simple initialization with auto
2133 void foo() {
2134 ^[[auto]] i = 1;
2135 }
2141 }},
2142 {
2143 R"cpp(// Simple initialization with const auto
2144 void foo() {
2145 const ^[[auto]] i = 1;
2146 }
2152 }},
2153 {
2154 R"cpp(// Simple initialization with const auto&
2155 void foo() {
2156 const ^[[auto]]& i = 1;
2157 }
2163 }},
2164 {
2165 R"cpp(// Simple initialization with auto&
2166 void foo() {
2167 int x;
2168 ^[[auto]]& i = x;
2169 }
2175 }},
2176 {
2177 R"cpp(// Simple initialization with auto*
2178 void foo() {
2179 int a = 1;
2180 ^[[auto]]* i = &a;
2181 }
2187 }},
2188 {
2189 R"cpp(// Simple initialization with auto from pointer
2190 void foo() {
2191 int a = 1;
2192 ^[[auto]] i = &a;
2193 }
2199 }},
2200 {
2201 R"cpp(// Auto with initializer list.
2202 namespace std
2203 {
2204 template<class _E>
2205 class initializer_list {};
2206 }
2207 void foo() {
2208 ^[[auto]] i = {1,2};
2209 }
2215 }},
2216 {
2217 R"cpp(// User defined conversion to auto
2218 struct Bar {
2219 operator ^[[auto]]() const { return 10; }
2220 };
2226 }},
2227 {
2228 R"cpp(// Simple initialization with decltype(auto)
2229 void foo() {
2230 ^[[decltype]](auto) i = 1;
2231 }
2237 }},
2238 {
2239 R"cpp(// Simple initialization with const decltype(auto)
2240 void foo() {
2241 const int j = 0;
2242 ^[[decltype]](auto) i = j;
2243 }
2249 }},
2250 {
2251 R"cpp(// Simple initialization with const& decltype(auto)
2252 void foo() {
2253 int k = 0;
2254 const int& j = k;
2255 ^[[decltype]](auto) i = j;
2256 }
2262 }},
2263 {
2264 R"cpp(// Simple initialization with & decltype(auto)
2265 void foo() {
2266 int k = 0;
2267 int& j = k;
2268 ^[[decltype]](auto) i = j;
2269 }
2275 }},
2276 {
2277 R"cpp(// simple trailing return type
2278 ^[[auto]] main() -> int {
2279 return 0;
2280 }
2286 }},
2287 {
2288 R"cpp(// auto function return with trailing type
2289 struct Bar {};
2290 ^[[auto]] test() -> decltype(Bar()) {
2291 return Bar();
2292 }
2299 }},
2300 {
2301 R"cpp(// trailing return type
2302 struct Bar {};
2303 auto test() -> ^[[decltype]](Bar()) {
2304 return Bar();
2305 }
2312 }},
2313 {
2314 R"cpp(// auto in function return
2315 struct Bar {};
2316 ^[[auto]] test() {
2317 return Bar();
2318 }
2325 }},
2326 {
2327 R"cpp(// auto& in function return
2328 struct Bar {};
2329 ^[[auto]]& test() {
2330 static Bar x;
2331 return x;
2332 }
2339 }},
2340 {
2341 R"cpp(// auto* in function return
2342 struct Bar {};
2343 ^[[auto]]* test() {
2344 Bar* bar;
2345 return bar;
2346 }
2353 }},
2354 {
2355 R"cpp(// const auto& in function return
2356 struct Bar {};
2357 const ^[[auto]]& test() {
2358 static Bar x;
2359 return x;
2360 }
2367 }},
2368 {
2369 R"cpp(// decltype(auto) in function return
2370 struct Bar {};
2371 ^[[decltype]](auto) test() {
2372 return Bar();
2373 }
2380 }},
2381 {
2382 R"cpp(// decltype(auto) reference in function return
2383 ^[[decltype]](auto) test() {
2384 static int a;
2385 return (a);
2386 }
2392 }},
2393 {
2394 R"cpp(// decltype lvalue reference
2395 void foo() {
2396 int I = 0;
2397 ^[[decltype]](I) J = I;
2398 }
2404 }},
2405 {
2406 R"cpp(// decltype lvalue reference
2407 void foo() {
2408 int I= 0;
2409 int &K = I;
2410 ^[[decltype]](K) J = I;
2411 }
2417 }},
2418 {
2419 R"cpp(// decltype lvalue reference parenthesis
2420 void foo() {
2421 int I = 0;
2422 ^[[decltype]]((I)) J = I;
2423 }
2429 }},
2430 {
2431 R"cpp(// decltype rvalue reference
2432 void foo() {
2433 int I = 0;
2434 ^[[decltype]](static_cast<int&&>(I)) J = static_cast<int&&>(I);
2435 }
2441 }},
2442 {
2443 R"cpp(// decltype rvalue reference function call
2444 int && bar();
2445 void foo() {
2446 int I = 0;
2447 ^[[decltype]](bar()) J = bar();
2448 }
2454 }},
2455 {
2456 R"cpp(// decltype of function with trailing return type.
2457 struct Bar {};
2458 auto test() -> decltype(Bar()) {
2459 return Bar();
2460 }
2461 void foo() {
2462 ^[[decltype]](test()) i = test();
2463 }
2471 }},
2472 {
2473 R"cpp(// decltype of var with decltype.
2474 void foo() {
2475 int I = 0;
2476 decltype(I) J = I;
2477 ^[[decltype]](J) K = J;
2478 }
2484 }},
2485 {
2486 R"cpp(// decltype of dependent type
2487 template <typename T>
2488 struct X {
2489 using Y = ^[[decltype]](T::Z);
2490 };
2496 }},
2497 {
2498 R"cpp(// More complicated structured types.
2499 int bar();
2500 ^[[auto]] (*foo)() = bar;
2506 }},
2507 {
2508 R"cpp(// Should not crash when evaluating the initializer.
2509 struct Test {};
2510 void test() { Test && [[te^st]] = {}; }
2519 }},
2520 {
2521 R"cpp(// auto on alias
2522 typedef int int_type;
2523 ^[[auto]] x = int_type();
2529 }},
2530 {
2531 R"cpp(// auto on alias
2532 struct cls {};
2533 typedef cls cls_type;
2534 ^[[auto]] y = cls_type();
2541 }},
2542 {
2543 R"cpp(// auto on alias
2544 template <class>
2545 struct templ {};
2546 ^[[auto]] z = templ<int>();
2553 }},
2554 {
2555 R"cpp(// Undeduced auto declaration
2556 template<typename T>
2557 void foo() {
2558 ^[[auto]] x = T();
2559 }
2565 }},
2566 {
2567 R"cpp(// Undeduced auto return type
2568 template<typename T>
2569 ^[[auto]] foo() {
2570 return T();
2571 }
2577 }},
2578 {
2579 R"cpp(// Template auto parameter
2580 template<[[a^uto]] T>
2581 void func() {
2582 }
2585 // FIXME: not sure this is what we want, but this
2586 // is what we currently get with getDeducedType
2590 }},
2591 {
2592 R"cpp(// Undeduced decltype(auto) return type
2593 template<typename T>
2594 ^[[decltype]](auto) foo() {
2595 return T();
2596 }
2602 }},
2603 {
2604 R"cpp(// should not crash.
2605 template <class T> struct cls {
2606 int method();
2607 };
2609 auto test = cls<int>().[[m^ethod]]();
2620 }},
2621 {
2622 R"cpp(// type of nested templates.
2623 template <class T> struct cls {};
2624 cls<cls<cls<int>>> [[fo^o]];
2632 }},
2633 {
2634 R"cpp(// type of nested templates.
2635 template <class T> struct cls {};
2636 [[cl^s]]<cls<cls<int>>> foo;
2644 }},
2645 {
2646 R"cpp(// type with decltype
2647 int a;
2655 }},
2656 {
2657 R"cpp(// type with decltype
2658 int a;
2659 decltype(a) c;
2667 }},
2668 {
2669 R"cpp(// type with decltype
2670 int a;
2678 }},
2679 {
2680 R"cpp(// type with decltype
2681 int a;
2688 // FIXME: Handle composite types with decltype with a printing
2689 // policy.
2694 }},
2695 {
2696 R"cpp(// sizeof expr
2697 void foo() {
2698 (void)[[size^of]](char);
2704 }},
2705 {
2706 R"cpp(// alignof expr
2707 void foo() {
2708 (void)[[align^of]](char);
2714 }},
2715 {
2716 R"cpp(
2717 template <typename T = int>
2718 void foo(const T& = T()) {
2719 [[f^oo]]<>(3);
2730 }},
2731 {
2732 R"cpp(// should not crash
2733 @interface ObjC {
2734 char [[da^ta]];
2735 }@end
2744 }},
2745 {
2746 R"cpp(
2747 @interface MYObject
2748 @end
2749 @interface Interface
2750 @property(retain) [[MYOb^ject]] *x;
2751 @end
2758 }},
2759 {
2760 R"cpp(
2761 @interface MYObject
2762 @end
2763 @interface Interface
2764 - (void)doWith:([[MYOb^ject]] *)object;
2765 @end
2772 }},
2773 {
2774 R"cpp(// this expr
2775 // comment
2776 namespace ns {
2777 class Foo {
2778 Foo* bar() {
2779 return [[t^his]];
2780 }
2781 };
2782 }
2787 }},
2788 {
2789 R"cpp(// this expr for template class
2790 namespace ns {
2791 template <typename T>
2792 class Foo {
2793 Foo* bar() const {
2794 return [[t^his]];
2795 }
2796 };
2797 }
2802 }},
2803 {
2804 R"cpp(// this expr for specialization class
2805 namespace ns {
2806 template <typename T> class Foo {};
2807 template <>
2808 struct Foo<int> {
2809 Foo* bar() {
2810 return [[thi^s]];
2811 }
2812 };
2813 }
2818 }},
2819 {
2820 R"cpp(// this expr for partial specialization struct
2821 namespace ns {
2822 template <typename T, typename F> struct Foo {};
2823 template <typename F>
2824 struct Foo<int, F> {
2825 Foo* bar() const {
2826 return [[thi^s]];
2827 }
2828 };
2829 }
2834 }},
2835 {
2836 R"cpp(
2837 @interface MYObject
2838 @end
2839 @interface MYObject (Private)
2840 @property(nonatomic, assign) int privateField;
2841 @end
2843 int someFunction() {
2844 MYObject *obj = [MYObject sharedInstance];
2845 return obj.[[private^Field]];
2846 }
2855 }},
2856 {
2857 R"cpp(
2858 @protocol MYProtocol
2859 @property(nonatomic, assign) int prop1;
2860 @end
2862 int someFunction() {
2863 id<MYProtocol> obj = 0;
2864 return obj.[[pro^p1]];
2865 }
2874 }},
2875 {
2876 R"cpp(
2877 @protocol MYProtocol
2878 @end
2879 @interface MYObject
2880 @end
2882 @interface MYObject (Ext) <[[MYProt^ocol]]>
2883 @end
2890 }},
2892 @interface Foo
2893 @end
2895 @implementation Foo(Private)
2896 + (int)somePrivateMethod {
2897 int [[res^ult]] = 2;
2898 return result;
2899 }
2900 @end
2910 }},
2912 @interface Foo
2913 @end
2915 @implementation Foo
2916 - (int)variadicArgMethod:(id)first, ... {
2917 int [[res^ult]] = 0;
2918 return result;
2919 }
2920 @end
2930 }},
2932 void foo(int * __attribute__(([[non^null]], noescape)) );
2939 }},
2940 {
2941 R"cpp(
2942 namespace std {
2943 struct strong_ordering {
2944 int n;
2945 constexpr operator int() const { return n; }
2946 static const strong_ordering equal, greater, less;
2947 };
2948 constexpr strong_ordering strong_ordering::equal = {0};
2949 constexpr strong_ordering strong_ordering::greater = {1};
2950 constexpr strong_ordering strong_ordering::less = {-1};
2951 }
2953 struct Foo
2954 {
2955 int x;
2956 // Foo spaceship
2957 auto operator<=>(const Foo&) const = default;
2958 };
2960 bool x = Foo(1) [[!^=]] Foo(2);
2974 }},
2975 };
2977 // Create a tiny index, so tests above can verify documentation is fetched.
2994 // Types might be different depending on the target triplet, we chose a
2995 // fixed one to make sure tests passes on different platform.
2998 Config Cfg;
3003 HoverInfo Expected;
3020 }
3021 }
3028 struct Foo {};
3029 Foo F = Fo^o{};
3034 Foo F = Fo^o{};
3039 Foo F = Fo^o{};
3043 #define FOO 5
3044 int F = ^FOO;
3049 int F = ^FOO;
3054 int F = ^FOO;
3059 Foo A;
3060 Foo B;
3061 Foo C = A ^+ B;
3064 // Hover selects the underlying decl of the using decl
3067 namespace ns {
3068 using ::Foo;
3069 }
3070 ns::F^oo d;
3074 namespace foo {};
3075 using namespace fo^o;
3078 };
3084 TestTU TU;
3088 #define FOO 1
3089 class Foo {};
3090 Foo& operator+(const Foo, const Foo);
3097 HoverInfo Expected;
3101 }
3102 }
3105 HoverInfo HIFoo;
3109 HoverInfo HIFooBar;
3113 HoverInfo HI;
3120 }
3128 int fstBar = bar1();
3129 int another= bar1(0);
3130 int sndBar = bar2();
3131 Bar bar;
3132 int macroBar = BAR;
3136 }},
3138 #in^clude <vector>
3139 std::vector<int> vec;
3146 TestTU TU;
3150 #define BAR 5
3151 int bar1();
3152 int bar2();
3153 int bar1(double);
3154 class Bar {};
3157 namespace std {
3158 template<typename>
3159 class vector{};
3160 }
3167 HoverInfo Expected;
3171 }
3172 }
3176 template <typename T> class X {};
3177 void foo() {
3178 auto t = X<int>();
3179 X^<int> w;
3180 (void)w;
3185 Symbol IndexSym;
3197 }
3198 }
3202 // doc
3203 template <typename T> class X {};
3204 // doc
3205 template <typename T> void bar() {}
3206 // doc
3207 template <typename T> T baz;
3208 void foo() {
3209 au^to t = X<int>();
3210 X^<int>();
3211 b^ar<int>();
3212 au^to T = ba^z<X<int>>;
3213 ba^z<int> = 0;
3222 }
3223 }
3227 /* error-ok */
3228 template<typename T> T foo(T);
3230 // Setter variable heuristic might fail if the callexpr is broken.
3237 }
3241 constexpr unsigned long value = -1; // wrap around
3242 void foo() { va^lue; }
3246 }
3250 // doc1
3251 template <typename T> class $doc1^X {};
3252 // doc2
3253 template <> class $doc2^X<int> {};
3254 // doc3
3255 template <typename T> class $doc3^X<T*> {};
3256 void foo() {
3257 X$doc1^<char>();
3258 X$doc2^<int>();
3259 X$doc3^<int*>();
3269 }
3270 }
3271 }
3278 {
3282 },
3284 },
3285 {
3289 },
3291 },
3292 {
3299 };
3305 },
3306 R"(class foo
3308 Size: 10 bytes
3309 documentation
3312 },
3313 {
3330 },
3342 },
3343 {
3354 },
3355 R"(field foo
3357 Type: type (aka can_type)
3358 Value = value
3359 Offset: 12 bytes
3360 Size: 4 bytes (+4 bytes padding)
3362 // In test::Bar
3364 },
3365 {
3376 },
3377 R"(field foo
3379 Type: type (aka can_type)
3380 Value = value
3381 Offset: 4 bytes and 3 bits
3382 Size: 25 bits (+4 bits padding)
3384 // In test::Bar
3386 },
3387 {
3394 },
3395 R"(field foo
3397 // In test::Bar
3399 },
3400 {
3411 },
3412 R"(instance-method method
3414 → size_t (aka unsigned long)
3416 // In cls<int>
3418 },
3419 {
3435 },
3436 R"(constructor cls
3438 Parameters:
3439 - int a
3440 - int b = 5
3442 // In cls
3444 },
3445 {
3452 },
3453 R"(union foo
3455 // In namespace ns1
3457 },
3458 {
3471 },
3472 R"(variable foo
3474 Type: int
3475 Value = 3
3476 Passed as arg_a
3478 // In test::Bar
3480 },
3481 {
3488 },
3489 R"(variable foo
3492 },
3493 {
3506 },
3507 R"(variable foo
3509 Type: int
3510 Value = 3
3511 Passed by reference as arg_a
3513 // In test::Bar
3515 },
3516 {
3529 },
3530 R"(variable foo
3532 Type: int
3533 Value = 3
3534 Passed as arg_a (converted to alias_int)
3536 // In test::Bar
3538 },
3539 {
3546 },
3547 R"(macro PLUS_ONE
3549 #define PLUS_ONE(X) (X+1)
3551 // Expands to
3553 },
3554 {
3567 },
3568 R"(variable foo
3570 Type: int
3571 Value = 3
3572 Passed by const reference as arg_a (converted to int)
3574 // In test::Bar
3576 },
3577 {
3581 },
3582 R"(stdio.h
3585 },
3589 },
3590 R"(foo.h
3596 },
3597 R"(foo.h
3602 HoverInfo HI;
3604 Config Cfg;
3608 }
3609 }
3620 },
3621 {
3625 },
3626 {
3630 },
3631 {
3635 },
3636 {
3640 },
3641 {
3645 },
3646 {
3650 },
3651 {
3655 },
3656 {
3660 },
3661 {
3665 },
3666 {
3670 },
3671 {
3675 },
3676 {
3680 },
3681 {
3685 }};
3693 }
3694 }
3696 // This is a separate test as headings don't create any differences in
3697 // plaintext mode.
3699 HoverInfo HI;
3704 }
3706 // This is a separate test as rulers behave differently in markdown vs
3707 // plaintext.
3709 HoverInfo HI;
3729 Value = val
3733 }
3737 namespace std {
3738 struct strong_ordering {
3739 int n;
3740 constexpr operator int() const { return n; }
3741 static const strong_ordering equal, greater, less;
3742 };
3743 constexpr strong_ordering strong_ordering::equal = {0};
3744 constexpr strong_ordering strong_ordering::greater = {1};
3745 constexpr strong_ordering strong_ordering::less = {-1};
3746 }
3748 template <typename T>
3749 struct S {
3750 // Foo bar baz
3751 friend auto operator<=>(S, S) = default;
3752 };
3753 static_assert(S<void>() =^= S<void>());
3761 }
3765 struct Foo;
3766 int bar;
3767 auto baz = (Fo^o*)&bar;
3775 }
3783 // error-ok testing behavior on invalid decl
3784 class Foo {};
3785 void foo(Foo p^aram = nullptr);
3789 class Foo {};
3790 void foo(Foo *p^aram = nullptr);
3793 };
3802 }
3803 }
3807 using m_int = int;
3808 m_int ^[[a]];
3811 Config Cfg;
3822 }
3826 #define A(x) x, x, x, x
3827 #define B(x) A(A(A(A(x))))
3828 int a^rr[] = {B(0)};
3837 }
3839 #if defined(__aarch64__)
3840 // FIXME: AARCH64 sanitizer buildbots are broken after 72142fbac4.
3841 #define PREDEFINEMACROS_TEST(x) DISABLED_##x
3842 #else
3843 #define PREDEFINEMACROS_TEST(x) x
3844 #endif
3848 using uintptr_t = __UINTPTR_TYPE__;
3849 enum Test : uintptr_t {};
3850 unsigned global_var;
3851 void foo() {
3852 Test v^al = static_cast<Test>(reinterpret_cast<uintptr_t>(&global_var));
3853 }
3862 }
3866 using uintptr_t = __UINTPTR_TYPE__;
3867 unsigned global_var;
3868 void foo() {
3869 uintptr_t a^ddress = reinterpret_cast<uintptr_t>(&global_var);
3870 }
3879 }
3883 template <bool X, typename T, typename F>
3884 struct cond { using type = T; };
3885 template <typename T, typename F>
3886 struct cond<false, T, F> { using type = F; };
3888 template <bool X, typename T, typename F>
3889 using type = typename cond<X, T, F>::type;
3891 void foo() {
3892 using f^oo = type<true, int, double>;
3893 }
3903 }
3907 #define X 42
3908 #define SizeOf sizeof
3909 #define AlignOf alignof
3910 #define PLUS_TWO +2
3911 #define TWO 2
3913 using u64 = unsigned long long;
3914 // calculate (a ** b) % p
3915 constexpr u64 pow_with_mod(u64 a, u64 b, u64 p) {
3916 u64 ret = 1;
3917 while (b) {
3918 if (b & 1)
3919 ret = (ret * a) % p;
3920 a = (a * a) % p;
3921 b >>= 1;
3922 }
3923 return ret;
3924 }
3925 #define last_n_digit(x, y, n) \
3926 pow_with_mod(x, y, pow_with_mod(10, n, 2147483647))
3927 #define declare_struct(X, name, value) \
3928 struct X { \
3929 constexpr auto name() { return value; } \
3930 }
3931 #define gnu_statement_expression(value) \
3932 ({ \
3933 declare_struct(Widget, getter, value); \
3934 Widget().getter(); \
3935 })
3936 #define define_lambda_begin(lambda, ...) \
3937 [&](__VA_ARGS__) {
3938 #define define_lambda_end() }
3940 #define left_bracket [
3941 #define right_bracket ]
3942 #define dg_left_bracket <:
3943 #define dg_right_bracket :>
3944 #define array_decl(type, name, size) type name left_bracket size right_bracket
3950 Validator;
3952 {
3954 X^;
3956 /*Validator=*/
3960 },
3961 },
3962 {
3964 Size^Of(int);
3966 /*Validator=*/
3970 // Don't validate type or value of `sizeof` and `alignof` as we're
3971 // getting different values or desugared types on different
3972 // platforms. Same as below.
3973 },
3974 },
3975 {
3977 struct Y {
3978 int y;
3979 double z;
3980 };
3981 Alig^nOf(Y);
3983 /*Validator=*/
3987 },
3988 },
3989 {
3991 // 2**32 == 4294967296
3992 last_n_di^git(2, 32, 6);
3994 /*Validator=*/
3998 },
3999 },
4000 {
4002 gnu_statement_exp^ression(42);
4004 /*Validator=*/
4008 },
4009 },
4010 {
4012 40 + PLU^S_TWO;
4014 /*Validator=*/
4018 },
4019 },
4020 {
4022 40 PLU^S_TWO;
4024 /*Validator=*/
4028 },
4029 },
4030 {
4032 40 + TW^O;
4034 /*Validator=*/
4038 },
4039 },
4040 {
4042 arra^y_decl(int, vector, 10);
4043 vector left_b^racket 3 right_b^racket;
4044 vector dg_le^ft_bracket 3 dg_righ^t_bracket;
4046 /*Validator=*/
4061 }
4062 },
4063 },
4064 {
4066 constexpr auto value = define_lamb^da_begin(lambda, int, char)
4067 // Check if the expansion range is right.
4068 return ^last_n_digit(10, 3, 3)^;
4069 define_lam^bda_end();
4071 /*Validator=*/
4091 }
4092 },
4093 },
4094 };
4096 Config Cfg;
4107 Index);
4108 }
4109 }
4112 #define alignof _Alignof
4113 void foo() {
4114 al^ignof(struct { int x; char y[10]; });
4115 }
4122 };
4129 }