llvm-project
2652 строки · 87.7 Кб
1#include "clang/AST/ASTContext.h"2#include "clang/AST/ASTStructuralEquivalence.h"3#include "clang/AST/Decl.h"4#include "clang/AST/DeclTemplate.h"5#include "clang/ASTMatchers/ASTMatchers.h"6#include "clang/Frontend/ASTUnit.h"7#include "clang/Testing/CommandLineArgs.h"8#include "clang/Tooling/Tooling.h"9#include "llvm/TargetParser/Host.h"10}185}190}195// This test is disabled for now.197// FIXME Whether this is equivalent is dependent on the target.198TEST_F(StructuralEquivalenceTest, DISABLED_CharVsSignedChar) {199auto Decls = makeNamedDecls("char foo;", "signed char foo;", Lang_CXX03);200EXPECT_FALSE(testStructuralMatch(Decls));201}202}207}213}219}229}239struct true_type{};244template <class T> struct foo;245template<> struct foo<char> : true_type {};246)",247R"(248struct true_type{};249template <class T> struct foo;250template<> struct foo<signed char> : true_type {};251)",252Lang_CXX03, classTemplateSpecializationDecl());253EXPECT_FALSE(testStructuralMatch(Decls));254}255// This test is disabled for now.257// FIXME Enable it, once the check is implemented.258TEST_F(StructuralEquivalenceTest, DISABLED_WrongOrderInNamespace) {259auto Code =260R"(261namespace NS {262template <class T> class Base {263int a;264};265class Derived : Base<Derived> {266};267}268void foo(NS::Derived &);269)";270auto Decls = makeNamedDecls(Code, Code, Lang_CXX03);271}283}299}308}316}324}331}337}343}348}354}360}366}372}378}384}390}396}401}406}412}417}422}427}433}438}443}451}459}465}476}486}496}502}510}516}522}528}534}541}547}554}561}569}577}585}594}602}610}625}631}638}644}651}659struct A{ };663struct B{ };664struct foo: A, virtual B {665void x();666int a;667};668)";669auto t = makeNamedDecls(Code, Code, Lang_CXX03);670EXPECT_TRUE(testStructuralMatch(t));671}672struct A {677struct {678struct A *next;679} entry0;680struct {681struct A *next;682} entry1;683};684)",685"", Lang_C99);686auto *TU = get<0>(t);687auto *Entry0 =688FirstDeclMatcher<FieldDecl>().match(TU, fieldDecl(hasName("entry0")));689auto *Entry1 =690FirstDeclMatcher<FieldDecl>().match(TU, fieldDecl(hasName("entry1")));691auto *R0 = getRecordDecl(Entry0);692auto *R1 = getRecordDecl(Entry1);693}699struct X {704struct {705int a;706};707struct {708int b;709};710};711)",712"", Lang_C99);713auto *TU = get<0>(t);714auto *A = FirstDeclMatcher<IndirectFieldDecl>().match(715TU, indirectFieldDecl(hasName("a")));716auto *FA = cast<FieldDecl>(A->chain().front());717RecordDecl *RA = cast<RecordType>(FA->getType().getTypePtr())->getDecl();718auto *B = FirstDeclMatcher<IndirectFieldDecl>().match(719TU, indirectFieldDecl(hasName("b")));720auto *FB = cast<FieldDecl>(B->chain().front());721RecordDecl *RB = cast<RecordType>(FB->getType().getTypePtr())->getDecl();722}728struct X {734struct { int a; };735struct { int b; };736};737)",738R"(739struct X { // The order is reversed.740struct { int b; };741struct { int a; };742};743)",744Lang_C99);745}770struct A {776struct {777struct A *next;778} entry0;779struct {780struct A *next;781} entry1;782};783)";784auto t = makeTuDecls(Code, Code, Lang_C99);785}806}813}819}826}833}839}846}853}860}876}888}900}912}919}929}939}947}953}959}965}971}978}986}993}1000}1007}1013}1019}1026template <typename T> struct O {1032struct M {};1033};1034)";1035auto t = makeDecls<VarDecl>(Code + R"(1036typedef O<int>::M MT1;1037MT1 A;1038)",1039Code + R"(1040namespace {1041struct I {};1042} // namespace1043typedef O<I>::M MT2;1044MT2 A;1045)",1046Lang_CXX11, varDecl(hasName("A")));1047EXPECT_FALSE(testStructuralMatch(t));1048}1049class X;1054class Y { X* x; };1055)",1056R"(1057namespace N { class X; }1058class Y { N::X* x; };1059)",1060Lang_CXX03, "Y");1061EXPECT_FALSE(testStructuralMatch(Decls));1062}1063}1070}1077}1084}1091}1098}1105}1111}1119}1126}1133}1140}1146}1153}1162}1169}1176}1188}1195}1203}1211}1221}1229}1237}1245}1253}1261}1269}1277}1285}1299}1307}1315}1323}1331}1338}1346}1354}1360}1366}1372}1378}1384}1392}1399}1410}1421template <typename P1> class Arg { };1427template <template <typename PP1> class P1> class Primary { };1428void f() {1430// Make specialization with simple template.1431Primary <Arg> A;1432}1433)",1434R"(1435template <typename P1> class Arg { };1436template <template <typename PP1> class P1> class Primary { };1437template <template <typename PP1> class P1> class Templ {1439void f() {1440// Make specialization with substituted template template param.1441Primary <P1> A;1442};1443};1444// Instantiate with substitution Arg into P1.1446template class Templ <Arg>;1447)",1448Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));1449EXPECT_TRUE(testStructuralMatch(t));1450}1451template <typename P1> class Arg { };1457template <template <typename PP1> class P1> class Primary { };1458void f() {1460// Make specialization with simple template.1461Primary <Arg> A;1462}1463)",1464R"(1465// Arg is different from the other, this should cause non-equivalence.1466template <typename P1> class Arg { int X; };1467template <template <typename PP1> class P1> class Primary { };1468template <template <typename PP1> class P1> class Templ {1470void f() {1471// Make specialization with substituted template template param.1472Primary <P1> A;1473};1474};1475// Instantiate with substitution Arg into P1.1477template class Templ <Arg>;1478)",1479Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));1480EXPECT_FALSE(testStructuralMatch(t));1481}1482template <typename>1491struct S1;1492template <typename>1494struct enable_if;1495struct S1497{1498template <typename T, typename enable_if<S1<T>>::type>1499void f();1500};1501)";1502auto t = makeDecls<FunctionTemplateDecl>(Code, Code, Lang_CXX11,1503functionTemplateDecl(hasName("f")));1504EXPECT_TRUE(testStructuralMatch(t));1505}1506template <typename>1512struct S1;1513template <typename>1515struct S2;1516template <typename>1518struct enable_if;1519)";1520auto t = makeDecls<FunctionTemplateDecl>(Code + R"(1521struct S1522{1523template <typename T, typename enable_if<S1<T>>::type>1524void f();1525};1526)",1527Code + R"(1528struct S1529{1530template <typename T, typename enable_if<S2<T>>::type>1531void f();1532};1533)",1534Lang_CXX11,1535functionTemplateDecl(hasName("f")));1536EXPECT_FALSE(testStructuralMatch(t));1537}1538template <typename>1544struct S1;1545template <bool>1547struct enable_if;1548struct S1550{1551template <typename T, typename enable_if<S1<T>::value>::type>1552void f(); // DependentScopeDeclRefExpr:^^^^^^^^^^^^1553};1554)";1555auto t = makeDecls<FunctionTemplateDecl>(Code, Code, Lang_CXX11,1556functionTemplateDecl(hasName("f")));1557EXPECT_TRUE(testStructuralMatch(t));1558}1559template <typename>1565struct S1;1566template <typename>1568struct S2;1569template <bool>1571struct enable_if;1572)";1573auto t = makeDecls<FunctionTemplateDecl>(Code + R"(1574struct S1575{1576template <typename T, typename enable_if<S1<T>::value>::type>1577void f(); // DependentScopeDeclRefExpr:^^^^^^^^^^^^1578};1579)",1580Code + R"(1581struct S1582{1583template <typename T, typename enable_if<S2<T>::value>::type>1584void f();1585};1586)",1587Lang_CXX03,1588functionTemplateDecl(hasName("f")));1589EXPECT_FALSE(testStructuralMatch(t));1590}1591template <typename>1597struct S1;1598template <bool>1600struct enable_if;1601)";1602auto t = makeDecls<FunctionTemplateDecl>(Code + R"(1603struct S1604{1605template <typename T, typename enable_if<S1<T>::value1>::type>1606void f(); // DependentScopeDeclRefExpr:^^^^^^^^^^^^1607};1608)",1609Code + R"(1610struct S1611{1612template <typename T, typename enable_if<S1<T>::value2>::type>1613void f();1614};1615)",1616Lang_CXX03,1617functionTemplateDecl(hasName("f")));1618EXPECT_FALSE(testStructuralMatch(t));1619}1620template <class T> struct Primary {};1627namespace N {1628struct Arg;1629}1630// Explicit instantiation with qualified name.1631template struct Primary<N::Arg>;1632)",1633R"(1634template <class T> struct Primary {};1635namespace N {1636struct Arg;1637}1638using namespace N;1639// Explicit instantiation with UNqualified name.1640template struct Primary<Arg>;1641)",1642Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));1643EXPECT_TRUE(testStructuralMatch(t));1644}1645template <class T> struct Primary {};1652namespace N {1653struct Arg { int a; };1654}1655// Explicit instantiation with qualified name.1656template struct Primary<N::Arg>;1657)",1658R"(1659template <class T> struct Primary {};1660namespace N {1661// This struct is not equivalent with the other in the prev TU.1662struct Arg { double b; }; // -- Field mismatch.1663}1664using namespace N;1665// Explicit instantiation with UNqualified name.1666template struct Primary<Arg>;1667)",1668Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));1669EXPECT_FALSE(testStructuralMatch(t));1670}1671template <template <class> class T> struct Primary {};1678namespace N {1679template <class T> struct Arg;1680}1681// Explicit instantiation with qualified name.1682template struct Primary<N::Arg>;1683)",1684R"(1685template <template <class> class T> struct Primary {};1686namespace N {1687template <class T> struct Arg;1688}1689using namespace N;1690// Explicit instantiation with UNqualified name.1691template struct Primary<Arg>;1692)",1693Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));1694EXPECT_TRUE(testStructuralMatch(t));1695}1696template <template <class> class T> struct Primary {};1703namespace N {1704template <class T> struct Arg { int a; };1705}1706// Explicit instantiation with qualified name.1707template struct Primary<N::Arg>;1708)",1709R"(1710template <template <class> class T> struct Primary {};1711namespace N {1712// This template is not equivalent with the other in the prev TU.1713template <class T> struct Arg { double b; }; // -- Field mismatch.1714}1715using namespace N;1716// Explicit instantiation with UNqualified name.1717template struct Primary<Arg>;1718)",1719Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));1720EXPECT_FALSE(testStructuralMatch(t));1721}1722template<class> struct A;1728)",1729R"(1730template<class> struct S {1731template<class> friend struct A;1732};1733)",1734Lang_CXX03, classTemplateDecl(hasName("A")),1735classTemplateDecl(hasName("A")));1736EXPECT_TRUE(testStructuralMatch(Decls));1737EXPECT_TRUE(testStructuralMatch(Decls, true));1738}1739template<class T, T U> struct A;1745)",1746R"(1747template<class T> struct S {1748template<class P, P Q> friend struct A;1749};1750)",1751Lang_CXX03, classTemplateDecl(hasName("A")),1752classTemplateDecl(hasName("A")));1753EXPECT_FALSE(testStructuralMatch(Decls));1754EXPECT_TRUE(testStructuralMatch(Decls, /*IgnoreTemplateParmDepth=*/true));1755}1756template <template <class> class T> struct Primary {};1763template <class T> struct Arg { int a; };1764// Explicit instantiation with ::Arg1765template struct Primary<Arg>;1766)",1767R"(1768template <template <class> class T> struct Primary {};1769template <class T> struct Arg { int a; };1770namespace N {1771// This template is not equivalent with the other in the global scope.1772template <class T> struct Arg { double b; }; // -- Field mismatch.1773// Explicit instantiation with N::Arg which shadows ::Arg1774template struct Primary<Arg>;1775}1776)",1777Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));1778EXPECT_FALSE(testStructuralMatch(t));1779}1780struct StructuralEquivalenceCacheTest : public StructuralEquivalenceTest {1781llvm::DenseSet<std::pair<Decl *, Decl *>> NonEquivalentDecls;1782class A {};1802class B {};1803void x(A, A);1804)",1805R"(1806class A {};1807class B {};1808void x(A, B);1809)",1810Lang_CXX03);1811}1824bool x() { return true; }1829)",1830R"(1831bool x() { return false; }1832)",1833Lang_CXX03);1834}1843int p;1848)",1849R"(1850int q;1851)",1852Lang_CXX03);1853}1861int p;1866)",1867R"(1868static int p;1869)",1870Lang_CXX03);1871}1879template<int T>1885struct A {1886template<int U>1887void foo() {}1888};1889)",1890R"(1891template<int U>1892struct A {1893template<int V, int T>1894void foo() {}1895};1896)",1897Lang_CXX03);1898}1907int p = 1;1912)",1913R"(1914int p = 2;1915)",1916Lang_CXX03);1917}1925class A {};1930class B { int i; };1931void x(A *);1932void y(A *);1933class C {1934friend void x(A *);1935friend void y(A *);1936};1937)",1938R"(1939class A {};1940class B { int i; };1941void x(A *);1942void y(B *);1943class C {1944friend void x(A *);1945friend void y(B *);1946};1947)",1948Lang_CXX03);1949}1968class C;1973class A { C *c; };1974void x(A *);1975class C {1976friend void x(A *);1977};1978)",1979R"(1980class C;1981class A { C *c; };1982void x(A *);1983class C {1984friend void x(A *);1985};1986)",1987Lang_CXX03);1988}2003/// Fallback matcher to be used only when there is no specific matcher for a2007/// Expr subclass. Remove this once all Expr subclasses have their own matcher.2008static auto &fallbackExprMatcher = expr;2009}2015}2022enum memory_order {2025memory_order_relaxed,2026memory_order_consume,2027memory_order_acquire,2028memory_order_release,2029memory_order_acq_rel,2030memory_order_seq_cst2031};2032)";2033}2044}2055}2060}2065}2071}2079}2084}2089}2095}2101}2106}2113}2118}2123}2130}2137}2144template <typename T>2149void f() {2150T x;2151(void)_Generic(x, int: 0, float: 1);2152}2153void g() { f<int>(); }2154)",2155R"(2156template <typename T>2157void f() {2158T x;2159(void)_Generic(x, int: 0, float: 1);2160}2161void g() { f<int>(); }2162)",2163Lang_CXX03, genericSelectionExpr());2164EXPECT_TRUE(testStructuralMatch(t));2165}2166template <typename T>2172void f() {2173T x;2174(void)_Generic(x, float: 1, int: 0);2175}2176void g() { f<int>(); }2177)",2178R"(2179template <typename T>2180void f() {2181T x;2182(void)_Generic(x, int: 0, float: 1);2183}2184void g() { f<int>(); }2185)",2186Lang_CXX03, genericSelectionExpr());2187}2190TEST_F(StructuralEquivalenceStmtTest, IntegerLiteral) {2191auto t = makeWrappedStmts("1", "1", Lang_CXX03, integerLiteral());2192EXPECT_TRUE(testStructuralMatch(t));2193}2194}2200}2205}2210}2218}2226}2232}2238}2243}2248}2253}2259}2265}2271}2277}2283}2289}2295}2300}2305template <typename T, T x>2311class A;2312template <typename T, T x, T y>2313void foo(2314A<T, x + y>,2315A<T, x - y>,2316A<T, -x>,2317A<T, x * y>,2318A<T, *x>,2319A<T, x / y>,2320A<T, x % y>,2321A<T, x ^ y>,2322A<T, x & y>,2323A<T, &x>,2324A<T, x | y>,2325A<T, ~x>,2326A<T, !x>,2327A<T, x < y>,2328A<T, (x > y)>,2329A<T, x << y>,2330A<T, (x >> y)>,2331A<T, x == y>,2332A<T, x != y>,2333A<T, x <= y>,2334A<T, x >= y>,2335A<T, x <=> y>,2336A<T, x && y>,2337A<T, x || y>,2338A<T, ++x>,2339A<T, --x>,2340A<T, (x , y)>,2341A<T, x ->* y>,2342A<T, x -> y>2343);2344)",2345R"(2346struct Bar {2347Bar& operator=(Bar&);2348Bar& operator->();2349};2350Bar& operator+(Bar&, Bar&);2352Bar& operator+(Bar&);2353Bar& operator-(Bar&, Bar&);2354Bar& operator-(Bar&);2355Bar& operator*(Bar&, Bar&);2356Bar& operator*(Bar&);2357Bar& operator/(Bar&, Bar&);2358Bar& operator%(Bar&, Bar&);2359Bar& operator^(Bar&, Bar&);2360Bar& operator&(Bar&, Bar&);2361Bar& operator&(Bar&);2362Bar& operator|(Bar&, Bar&);2363Bar& operator~(Bar&);2364Bar& operator!(Bar&);2365Bar& operator<(Bar&, Bar&);2366Bar& operator>(Bar&, Bar&);2367Bar& operator+=(Bar&, Bar&);2368Bar& operator-=(Bar&, Bar&);2369Bar& operator*=(Bar&, Bar&);2370Bar& operator/=(Bar&, Bar&);2371Bar& operator%=(Bar&, Bar&);2372Bar& operator^=(Bar&, Bar&);2373Bar& operator&=(Bar&, Bar&);2374Bar& operator|=(Bar&, Bar&);2375Bar& operator<<(Bar&, Bar&);2376Bar& operator>>(Bar&, Bar&);2377Bar& operator<<=(Bar&, Bar&);2378Bar& operator>>=(Bar&, Bar&);2379Bar& operator==(Bar&, Bar&);2380Bar& operator!=(Bar&, Bar&);2381Bar& operator<=(Bar&, Bar&);2382Bar& operator>=(Bar&, Bar&);2383Bar& operator<=>(Bar&, Bar&);2384Bar& operator&&(Bar&, Bar&);2385Bar& operator||(Bar&, Bar&);2386Bar& operator++(Bar&);2387Bar& operator--(Bar&);2388Bar& operator,(Bar&, Bar&);2389Bar& operator->*(Bar&, Bar&);2390template <typename T, T x>2392class A;2393template <typename T, T x, T y>2394void foo(2395A<T, x + y>,2396A<T, x - y>,2397A<T, -x>,2398A<T, x * y>,2399A<T, *x>,2400A<T, x / y>,2401A<T, x % y>,2402A<T, x ^ y>,2403A<T, x & y>,2404A<T, &x>,2405A<T, x | y>,2406A<T, ~x>,2407A<T, !x>,2408A<T, x < y>,2409A<T, (x > y)>,2410A<T, x << y>,2411A<T, (x >> y)>,2412A<T, x == y>,2413A<T, x != y>,2414A<T, x <= y>,2415A<T, x >= y>,2416A<T, x <=> y>,2417A<T, x && y>,2418A<T, x || y>,2419A<T, ++x>,2420A<T, --x>,2421A<T, (x , y)>,2422A<T, x ->* y>,2423A<T, x -> y>2424);2425)",2426Lang_CXX20);2427EXPECT_TRUE(testStructuralMatch(t));2428}2429template <typename T, T x>2435class A;2436template <typename T, T x, T y>2437void foo(2438A<T, x + y>2439);2440)",2441R"(2442struct Bar;2443Bar& operator-(Bar&, Bar&);2445template <typename T, T x>2447class A;2448template <typename T, T x, T y>2449void foo(2450A<T, x - y>2451);2452)",2453Lang_CXX11);2454EXPECT_FALSE(testStructuralMatch(t));2455}2456template <typename T, T x>2461class A;2462template <typename T, T x, T y>2463void foo(A<T, x>);2464)",2465R"(2466template <typename T, T x>2467class A;2468template <typename T, T x, T y>2469void foo(A<T, y>);2470)",2471Lang_CXX11);2472EXPECT_FALSE(testStructuralMatch(t));2473}2474void f1(int);2479template <typename T>2480void f(T t) {2481f1(t);2482}2483void g() { f<int>(1); }2484)",2485R"(2486void f2(int);2487template <typename T>2488void f(T t) {2489f2(t);2490}2491void g() { f<int>(1); }2492)",2493Lang_CXX03, unresolvedLookupExpr());2494EXPECT_FALSE(testStructuralMatch(t));2495}2496struct X {2501static void g(int);2502static void g(char);2503};2504template <typename T>2506void f(T t) {2507X::g(t);2508}2509void g() { f<int>(1); }2511)",2512R"(2513struct Y {2514static void g(int);2515static void g(char);2516};2517template <typename T>2519void f(T t) {2520Y::g(t);2521}2522void g() { f<int>(1); }2524)",2525Lang_CXX03, unresolvedLookupExpr());2526EXPECT_FALSE(testStructuralMatch(t));2527}2528struct A {};2534template<typename T1, typename T2>2535void g() {}2536template <typename T>2538void f() {2539g<A, T>();2540}2541void h() { f<int>(); }2543)",2544R"(2545struct B {};2546template<typename T1, typename T2>2547void g() {}2548template <typename T>2550void f() {2551g<B, T>();2552}2553void h() { f<int>(); }2555)",2556Lang_CXX03, unresolvedLookupExpr());2557EXPECT_FALSE(testStructuralMatch(t));2558}2559struct A {};2564struct B {2565template<typename T1, typename T2>2566static void g(int) {};2567template<typename T1, typename T2>2568static void g(char) {};2569};2570template <typename T1, typename T2>2572void f(T2 x) {2573B::g<A, T1>(x);2574}2575void g() { f<char, int>(1); }2577)",2578R"(2579struct A {};2580struct B {2581template<typename T1, typename T2>2582static void g(int) {};2583template<typename T1, typename T2>2584static void g(char) {};2585};2586template <typename T1, typename T2>2588void f(T2 x) {2589B::g<A, T1>(x);2590}2591void g() { f<char, int>(1); }2593)",2594Lang_CXX03, unresolvedLookupExpr());2595EXPECT_TRUE(testStructuralMatch(t));2596}2597void foo() {2602goto L1;2603L1: foo();2604}2605)",2606R"(2607void foo() {2608goto L2;2609L2: foo();2610}2611)",2612Lang_CXX03, gotoStmt());2613EXPECT_FALSE(testStructuralMatch(S));2614}2615}2624template <class T>2629void foo() {2630(void)T().x;2631}2632struct A { int x; };2633void bar() {2634foo<A>();2635}2636)",2637R"(2638template <class T>2639void foo() {2640(void)T().y;2641}2642struct A { int y; };2643void bar() {2644foo<A>();2645}2646)",2647Lang_CXX11, cxxDependentScopeMemberExpr());2648EXPECT_FALSE(testStructuralMatch(S));2649}2650