1 //===- unittest/AST/ASTTypeTraits.cpp - AST type traits unit tests ------===//
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 //===--------------------------------------------------------------------===//
8 
9 
10 #include "clang/AST/ASTTypeTraits.h"
11 #include "MatchVerifier.h"
12 #include "gtest/gtest.h"
13 
14 using namespace clang::ast_matchers;
15 
16 namespace clang {
17 namespace {
18 
19 TEST(ASTNodeKind, NoKind) {
20   EXPECT_FALSE(ASTNodeKind().isBaseOf(ASTNodeKind()));
21   EXPECT_FALSE(ASTNodeKind().isSame(ASTNodeKind()));
22 }
23 
24 template <typename T> static ASTNodeKind DNT() {
25   return ASTNodeKind::getFromNodeKind<T>();
26 }
27 
28 TEST(ASTNodeKind, IsNone) {
29   EXPECT_TRUE(ASTNodeKind().isNone());
30   EXPECT_FALSE(DNT<Decl>().isNone());
31   EXPECT_FALSE(DNT<VarDecl>().isNone());
32 }
33 
34 TEST(ASTNodeKind, Bases) {
35   EXPECT_TRUE(DNT<Decl>().isBaseOf(DNT<VarDecl>()));
36   EXPECT_FALSE(DNT<Decl>().isSame(DNT<VarDecl>()));
37   EXPECT_FALSE(DNT<VarDecl>().isBaseOf(DNT<Decl>()));
38 
39   EXPECT_TRUE(DNT<Decl>().isSame(DNT<Decl>()));
40 }
41 
42 TEST(DynTypedNode, Clades) {
43   EXPECT_TRUE(DNT<Stmt>().getCladeKind().isSame(DNT<Stmt>()));
44   EXPECT_TRUE(DNT<Decl>().getCladeKind().isSame(DNT<Decl>()));
45 
46   EXPECT_TRUE(DNT<CXXMethodDecl>().getCladeKind().isSame(DNT<Decl>()));
47   EXPECT_TRUE(DNT<CXXMemberCallExpr>().getCladeKind().isSame(DNT<Stmt>()));
48 
49   EXPECT_FALSE(DNT<CXXMemberCallExpr>().getCladeKind().isSame(DNT<Decl>()));
50 
51   EXPECT_TRUE(ASTNodeKind().getCladeKind().isNone());
52 }
53 
54 TEST(ASTNodeKind, BaseDistances) {
55   unsigned Distance = 1;
56   EXPECT_TRUE(DNT<Expr>().isBaseOf(DNT<Expr>(), &Distance));
57   EXPECT_EQ(0u, Distance);
58 
59   EXPECT_TRUE(DNT<Stmt>().isBaseOf(DNT<IfStmt>(), &Distance));
60   EXPECT_EQ(1u, Distance);
61 
62   Distance = 3;
63   EXPECT_TRUE(DNT<DeclaratorDecl>().isBaseOf(DNT<ParmVarDecl>(), &Distance));
64   EXPECT_EQ(2u, Distance);
65 }
66 
67 TEST(ASTNodeKind, SameBase) {
68   EXPECT_TRUE(DNT<Expr>().isBaseOf(DNT<CallExpr>()));
69   EXPECT_TRUE(DNT<Expr>().isBaseOf(DNT<BinaryOperator>()));
70   EXPECT_FALSE(DNT<CallExpr>().isBaseOf(DNT<BinaryOperator>()));
71   EXPECT_FALSE(DNT<BinaryOperator>().isBaseOf(DNT<CallExpr>()));
72 }
73 
74 TEST(ASTNodeKind, DiffBase) {
75   EXPECT_FALSE(DNT<Expr>().isBaseOf(DNT<ArrayType>()));
76   EXPECT_FALSE(DNT<QualType>().isBaseOf(DNT<FunctionDecl>()));
77   EXPECT_FALSE(DNT<Type>().isSame(DNT<QualType>()));
78 }
79 
80 TEST(ASTNodeKind, MostDerivedType) {
81   EXPECT_TRUE(DNT<BinaryOperator>().isSame(
82       ASTNodeKind::getMostDerivedType(DNT<Expr>(), DNT<BinaryOperator>())));
83   EXPECT_TRUE(DNT<BinaryOperator>().isSame(
84       ASTNodeKind::getMostDerivedType(DNT<BinaryOperator>(), DNT<Expr>())));
85   EXPECT_TRUE(DNT<VarDecl>().isSame(
86       ASTNodeKind::getMostDerivedType(DNT<VarDecl>(), DNT<VarDecl>())));
87 
88   // Not related. Returns nothing.
89   EXPECT_TRUE(
90       ASTNodeKind::getMostDerivedType(DNT<IfStmt>(), DNT<VarDecl>()).isNone());
91   EXPECT_TRUE(ASTNodeKind::getMostDerivedType(DNT<IfStmt>(),
92                                               DNT<BinaryOperator>()).isNone());
93 }
94 
95 TEST(ASTNodeKind, MostDerivedCommonAncestor) {
96   EXPECT_TRUE(DNT<Expr>().isSame(ASTNodeKind::getMostDerivedCommonAncestor(
97       DNT<Expr>(), DNT<BinaryOperator>())));
98   EXPECT_TRUE(DNT<Expr>().isSame(ASTNodeKind::getMostDerivedCommonAncestor(
99       DNT<BinaryOperator>(), DNT<Expr>())));
100   EXPECT_TRUE(DNT<VarDecl>().isSame(ASTNodeKind::getMostDerivedCommonAncestor(
101       DNT<VarDecl>(), DNT<VarDecl>())));
102 
103   // A little related. Returns the ancestor.
104   EXPECT_TRUE(
105       DNT<NamedDecl>().isSame(ASTNodeKind::getMostDerivedCommonAncestor(
106           DNT<CXXMethodDecl>(), DNT<RecordDecl>())));
107 
108   // Not related. Returns nothing.
109   EXPECT_TRUE(ASTNodeKind::getMostDerivedCommonAncestor(
110                   DNT<IfStmt>(), DNT<VarDecl>()).isNone());
111 }
112 
113 struct Foo {};
114 
115 TEST(ASTNodeKind, UnknownKind) {
116   // We can construct one, but it is nowhere in the hierarchy.
117   EXPECT_FALSE(DNT<Foo>().isSame(DNT<Foo>()));
118 }
119 
120 TEST(ASTNodeKind, Name) {
121   EXPECT_EQ("<None>", ASTNodeKind().asStringRef());
122 #define VERIFY_NAME(Node) EXPECT_EQ(#Node, DNT<Node>().asStringRef());
123   VERIFY_NAME(TemplateArgument);
124   VERIFY_NAME(NestedNameSpecifierLoc);
125   VERIFY_NAME(QualType);
126   VERIFY_NAME(TypeLoc);
127   VERIFY_NAME(CXXCtorInitializer);
128   VERIFY_NAME(NestedNameSpecifier);
129   VERIFY_NAME(Decl);
130   VERIFY_NAME(CXXRecordDecl);
131   VERIFY_NAME(Stmt);
132   VERIFY_NAME(CallExpr);
133   VERIFY_NAME(Type);
134   VERIFY_NAME(ConstantArrayType);
135 #undef VERIFY_NAME
136 }
137 
138 TEST(DynTypedNode, DeclSourceRange) {
139   RangeVerifier<DynTypedNode> Verifier;
140   Verifier.expectRange(1, 1, 1, 11);
141   EXPECT_TRUE(Verifier.match("void f() {}", decl()));
142 }
143 
144 TEST(DynTypedNode, StmtSourceRange) {
145   RangeVerifier<DynTypedNode> Verifier;
146   Verifier.expectRange(1, 10, 1, 11);
147   EXPECT_TRUE(Verifier.match("void f() {}", stmt()));
148 }
149 
150 TEST(DynTypedNode, TypeLocSourceRange) {
151   RangeVerifier<DynTypedNode> Verifier;
152   Verifier.expectRange(1, 1, 1, 8);
153   EXPECT_TRUE(Verifier.match("void f() {}", typeLoc(loc(functionType()))));
154 }
155 
156 TEST(DynTypedNode, NNSLocSourceRange) {
157   RangeVerifier<DynTypedNode> Verifier;
158   Verifier.expectRange(1, 33, 1, 34);
159   EXPECT_TRUE(Verifier.match("namespace N { typedef void T; } N::T f() {}",
160                              nestedNameSpecifierLoc()));
161 }
162 
163 TEST(DynTypedNode, DeclDump) {
164   DumpVerifier Verifier;
165   Verifier.expectSubstring("FunctionDecl");
166   EXPECT_TRUE(Verifier.match("void f() {}", functionDecl()));
167 }
168 
169 TEST(DynTypedNode, StmtDump) {
170   DumpVerifier Verifier;
171   Verifier.expectSubstring("CompoundStmt");
172   EXPECT_TRUE(Verifier.match("void f() {}", stmt()));
173 }
174 
175 TEST(DynTypedNode, DeclPrint) {
176   PrintVerifier Verifier;
177   Verifier.expectString("void f() {\n}\n");
178   EXPECT_TRUE(Verifier.match("void f() {}", functionDecl()));
179 }
180 
181 TEST(DynTypedNode, StmtPrint) {
182   PrintVerifier Verifier;
183   Verifier.expectString("{\n}\n");
184   EXPECT_TRUE(Verifier.match("void f() {}", stmt()));
185 }
186 
187 TEST(DynTypedNode, QualType) {
188   QualType Q;
189   DynTypedNode Node = DynTypedNode::create(Q);
190   EXPECT_TRUE(Node == Node);
191   EXPECT_FALSE(Node < Node);
192 }
193 
194 } // namespace
195 }  // namespace clang
196