1//===--- TestVisitor.h ------------------------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9/// 10/// \file 11/// \brief Defines utility templates for RecursiveASTVisitor related tests. 12/// 13//===----------------------------------------------------------------------===// 14 15#ifndef LLVM_CLANG_TEST_VISITOR_H 16#define LLVM_CLANG_TEST_VISITOR_H 17 18#include "clang/AST/ASTConsumer.h" 19#include "clang/AST/ASTContext.h" 20#include "clang/AST/RecursiveASTVisitor.h" 21#include "clang/Frontend/CompilerInstance.h" 22#include "clang/Frontend/FrontendAction.h" 23#include "clang/Tooling/Tooling.h" 24#include "gtest/gtest.h" 25#include <vector> 26 27namespace clang { 28 29/// \brief Base class for simple RecursiveASTVisitor based tests. 30/// 31/// This is a drop-in replacement for RecursiveASTVisitor itself, with the 32/// additional capability of running it over a snippet of code. 33/// 34/// Visits template instantiations and implicit code by default. 35template <typename T> 36class TestVisitor : public RecursiveASTVisitor<T> { 37public: 38 TestVisitor() { } 39 40 virtual ~TestVisitor() { } 41 42 enum Language { 43 Lang_C, 44 Lang_CXX98, 45 Lang_CXX11, 46 Lang_OBJC, 47 Lang_OBJCXX11, 48 Lang_CXX = Lang_CXX98 49 }; 50 51 /// \brief Runs the current AST visitor over the given code. 52 bool runOver(StringRef Code, Language L = Lang_CXX) { 53 std::vector<std::string> Args; 54 switch (L) { 55 case Lang_C: Args.push_back("-std=c99"); break; 56 case Lang_CXX98: Args.push_back("-std=c++98"); break; 57 case Lang_CXX11: Args.push_back("-std=c++11"); break; 58 case Lang_OBJC: Args.push_back("-ObjC"); break; 59 case Lang_OBJCXX11: 60 Args.push_back("-ObjC++"); 61 Args.push_back("-std=c++11"); 62 Args.push_back("-fblocks"); 63 break; 64 } 65 return tooling::runToolOnCodeWithArgs(CreateTestAction(), Code, Args); 66 } 67 68 bool shouldVisitTemplateInstantiations() const { 69 return true; 70 } 71 72 bool shouldVisitImplicitCode() const { 73 return true; 74 } 75 76protected: 77 virtual ASTFrontendAction* CreateTestAction() { 78 return new TestAction(this); 79 } 80 81 class FindConsumer : public ASTConsumer { 82 public: 83 FindConsumer(TestVisitor *Visitor) : Visitor(Visitor) {} 84 85 virtual void HandleTranslationUnit(clang::ASTContext &Context) { 86 Visitor->Context = &Context; 87 Visitor->TraverseDecl(Context.getTranslationUnitDecl()); 88 } 89 90 private: 91 TestVisitor *Visitor; 92 }; 93 94 class TestAction : public ASTFrontendAction { 95 public: 96 TestAction(TestVisitor *Visitor) : Visitor(Visitor) {} 97 98 virtual clang::ASTConsumer* CreateASTConsumer( 99 CompilerInstance&, llvm::StringRef dummy) { 100 /// TestConsumer will be deleted by the framework calling us. 101 return new FindConsumer(Visitor); 102 } 103 104 protected: 105 TestVisitor *Visitor; 106 }; 107 108 ASTContext *Context; 109}; 110 111/// \brief A RecursiveASTVisitor to check that certain matches are (or are 112/// not) observed during visitation. 113/// 114/// This is a RecursiveASTVisitor for testing the RecursiveASTVisitor itself, 115/// and allows simple creation of test visitors running matches on only a small 116/// subset of the Visit* methods. 117template <typename T, template <typename> class Visitor = TestVisitor> 118class ExpectedLocationVisitor : public Visitor<T> { 119public: 120 /// \brief Expect 'Match' *not* to occur at the given 'Line' and 'Column'. 121 /// 122 /// Any number of matches can be disallowed. 123 void DisallowMatch(Twine Match, unsigned Line, unsigned Column) { 124 DisallowedMatches.push_back(MatchCandidate(Match, Line, Column)); 125 } 126 127 /// \brief Expect 'Match' to occur at the given 'Line' and 'Column'. 128 /// 129 /// Any number of expected matches can be set by calling this repeatedly. 130 /// Each is expected to be matched exactly once. 131 void ExpectMatch(Twine Match, unsigned Line, unsigned Column) { 132 ExpectedMatches.push_back(ExpectedMatch(Match, Line, Column)); 133 } 134 135 /// \brief Checks that all expected matches have been found. 136 virtual ~ExpectedLocationVisitor() { 137 for (typename std::vector<ExpectedMatch>::const_iterator 138 It = ExpectedMatches.begin(), End = ExpectedMatches.end(); 139 It != End; ++It) { 140 It->ExpectFound(); 141 } 142 } 143 144protected: 145 /// \brief Checks an actual match against expected and disallowed matches. 146 /// 147 /// Implementations are required to call this with appropriate values 148 /// for 'Name' during visitation. 149 void Match(StringRef Name, SourceLocation Location) { 150 const FullSourceLoc FullLocation = this->Context->getFullLoc(Location); 151 152 for (typename std::vector<MatchCandidate>::const_iterator 153 It = DisallowedMatches.begin(), End = DisallowedMatches.end(); 154 It != End; ++It) { 155 EXPECT_FALSE(It->Matches(Name, FullLocation)) 156 << "Matched disallowed " << *It; 157 } 158 159 for (typename std::vector<ExpectedMatch>::iterator 160 It = ExpectedMatches.begin(), End = ExpectedMatches.end(); 161 It != End; ++It) { 162 It->UpdateFor(Name, FullLocation, this->Context->getSourceManager()); 163 } 164 } 165 166 private: 167 struct MatchCandidate { 168 std::string ExpectedName; 169 unsigned LineNumber; 170 unsigned ColumnNumber; 171 172 MatchCandidate(Twine Name, unsigned LineNumber, unsigned ColumnNumber) 173 : ExpectedName(Name.str()), LineNumber(LineNumber), 174 ColumnNumber(ColumnNumber) { 175 } 176 177 bool Matches(StringRef Name, FullSourceLoc const &Location) const { 178 return MatchesName(Name) && MatchesLocation(Location); 179 } 180 181 bool PartiallyMatches(StringRef Name, FullSourceLoc const &Location) const { 182 return MatchesName(Name) || MatchesLocation(Location); 183 } 184 185 bool MatchesName(StringRef Name) const { 186 return Name == ExpectedName; 187 } 188 189 bool MatchesLocation(FullSourceLoc const &Location) const { 190 return Location.isValid() && 191 Location.getSpellingLineNumber() == LineNumber && 192 Location.getSpellingColumnNumber() == ColumnNumber; 193 } 194 195 friend std::ostream &operator<<(std::ostream &Stream, 196 MatchCandidate const &Match) { 197 return Stream << Match.ExpectedName 198 << " at " << Match.LineNumber << ":" << Match.ColumnNumber; 199 } 200 }; 201 202 struct ExpectedMatch { 203 ExpectedMatch(Twine Name, unsigned LineNumber, unsigned ColumnNumber) 204 : Candidate(Name, LineNumber, ColumnNumber), Found(false) {} 205 206 void UpdateFor(StringRef Name, FullSourceLoc Location, SourceManager &SM) { 207 if (Candidate.Matches(Name, Location)) { 208 EXPECT_TRUE(!Found); 209 Found = true; 210 } else if (!Found && Candidate.PartiallyMatches(Name, Location)) { 211 llvm::raw_string_ostream Stream(PartialMatches); 212 Stream << ", partial match: \"" << Name << "\" at "; 213 Location.print(Stream, SM); 214 } 215 } 216 217 void ExpectFound() const { 218 EXPECT_TRUE(Found) 219 << "Expected \"" << Candidate.ExpectedName 220 << "\" at " << Candidate.LineNumber 221 << ":" << Candidate.ColumnNumber << PartialMatches; 222 } 223 224 MatchCandidate Candidate; 225 std::string PartialMatches; 226 bool Found; 227 }; 228 229 std::vector<MatchCandidate> DisallowedMatches; 230 std::vector<ExpectedMatch> ExpectedMatches; 231}; 232} 233 234#endif /* LLVM_CLANG_TEST_VISITOR_H */ 235