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 VERIFY_NAME(NonNullAttr); 136 #undef VERIFY_NAME 137 } 138 139 TEST(DynTypedNode, DeclSourceRange) { 140 RangeVerifier<DynTypedNode> Verifier; 141 Verifier.expectRange(1, 1, 1, 11); 142 EXPECT_TRUE(Verifier.match("void f() {}", decl())); 143 } 144 145 TEST(DynTypedNode, StmtSourceRange) { 146 RangeVerifier<DynTypedNode> Verifier; 147 Verifier.expectRange(1, 10, 1, 11); 148 EXPECT_TRUE(Verifier.match("void f() {}", stmt())); 149 } 150 151 TEST(DynTypedNode, TypeLocSourceRange) { 152 RangeVerifier<DynTypedNode> Verifier; 153 Verifier.expectRange(1, 1, 1, 8); 154 EXPECT_TRUE(Verifier.match("void f() {}", typeLoc(loc(functionType())))); 155 } 156 157 TEST(DynTypedNode, NNSLocSourceRange) { 158 RangeVerifier<DynTypedNode> Verifier; 159 Verifier.expectRange(1, 33, 1, 34); 160 EXPECT_TRUE(Verifier.match("namespace N { typedef void T; } N::T f() {}", 161 nestedNameSpecifierLoc())); 162 } 163 164 TEST(DynTypedNode, AttrSourceRange) { 165 RangeVerifier<DynTypedNode> Verifier; 166 Verifier.expectRange(1, 31, 1, 31); 167 EXPECT_TRUE(Verifier.match("void x(char *y __attribute__((nonnull)) );", 168 ast_matchers::attr())); 169 } 170 171 TEST(DynTypedNode, DeclDump) { 172 DumpVerifier Verifier; 173 Verifier.expectSubstring("FunctionDecl"); 174 EXPECT_TRUE(Verifier.match("void f() {}", functionDecl())); 175 } 176 177 TEST(DynTypedNode, StmtDump) { 178 DumpVerifier Verifier; 179 Verifier.expectSubstring("CompoundStmt"); 180 EXPECT_TRUE(Verifier.match("void f() {}", stmt())); 181 } 182 183 TEST(DynTypedNode, DeclPrint) { 184 PrintVerifier Verifier; 185 Verifier.expectString("void f() {\n}\n"); 186 EXPECT_TRUE(Verifier.match("void f() {}", functionDecl())); 187 } 188 189 TEST(DynTypedNode, StmtPrint) { 190 PrintVerifier Verifier; 191 Verifier.expectString("{\n}\n"); 192 EXPECT_TRUE(Verifier.match("void f() {}", stmt())); 193 } 194 195 TEST(DynTypedNode, QualType) { 196 QualType Q; 197 DynTypedNode Node = DynTypedNode::create(Q); 198 EXPECT_TRUE(Node == Node); 199 EXPECT_FALSE(Node < Node); 200 } 201 202 } // namespace 203 } // namespace clang 204