1 //===- TemplateArgumentVisitor.h - Visitor for TArg subclasses --*- C++ -*-===// 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 // This file defines the TemplateArgumentVisitor interface. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_CLANG_AST_TEMPLATEARGUMENTVISITOR_H 14 #define LLVM_CLANG_AST_TEMPLATEARGUMENTVISITOR_H 15 16 #include "clang/AST/TemplateBase.h" 17 18 namespace clang { 19 20 namespace templateargumentvisitor { 21 22 /// A simple visitor class that helps create template argument visitors. 23 template <template <typename> class Ref, typename ImplClass, 24 typename RetTy = void, typename... ParamTys> 25 class Base { 26 public: 27 #define REF(CLASS) typename Ref<CLASS>::type 28 #define DISPATCH(NAME) \ 29 case TemplateArgument::NAME: \ 30 return static_cast<ImplClass *>(this)->Visit##NAME##TemplateArgument( \ 31 TA, std::forward<ParamTys>(P)...) 32 33 RetTy Visit(REF(TemplateArgument) TA, ParamTys... P) { 34 switch (TA.getKind()) { 35 DISPATCH(Null); 36 DISPATCH(Type); 37 DISPATCH(Declaration); 38 DISPATCH(NullPtr); 39 DISPATCH(Integral); 40 DISPATCH(StructuralValue); 41 DISPATCH(Template); 42 DISPATCH(TemplateExpansion); 43 DISPATCH(Expression); 44 DISPATCH(Pack); 45 } 46 llvm_unreachable("TemplateArgument is not covered in switch!"); 47 } 48 49 // If the implementation chooses not to implement a certain visit 50 // method, fall back to the parent. 51 52 #define VISIT_METHOD(CATEGORY) \ 53 RetTy Visit##CATEGORY##TemplateArgument(REF(TemplateArgument) TA, \ 54 ParamTys... P) { \ 55 return VisitTemplateArgument(TA, std::forward<ParamTys>(P)...); \ 56 } 57 58 VISIT_METHOD(Null); 59 VISIT_METHOD(Type); 60 VISIT_METHOD(Declaration); 61 VISIT_METHOD(NullPtr); 62 VISIT_METHOD(Integral); 63 VISIT_METHOD(StructuralValue); 64 VISIT_METHOD(Template); 65 VISIT_METHOD(TemplateExpansion); 66 VISIT_METHOD(Expression); 67 VISIT_METHOD(Pack); 68 69 RetTy VisitTemplateArgument(REF(TemplateArgument), ParamTys...) { 70 return RetTy(); 71 } 72 73 #undef REF 74 #undef DISPATCH 75 #undef VISIT_METHOD 76 }; 77 78 } // namespace templateargumentvisitor 79 80 /// A simple visitor class that helps create template argument visitors. 81 /// 82 /// This class does not preserve constness of TemplateArgument references (see 83 /// also ConstTemplateArgumentVisitor). 84 template <typename ImplClass, typename RetTy = void, typename... ParamTys> 85 class TemplateArgumentVisitor 86 : public templateargumentvisitor::Base<std::add_lvalue_reference, ImplClass, 87 RetTy, ParamTys...> {}; 88 89 /// A simple visitor class that helps create template argument visitors. 90 /// 91 /// This class preserves constness of TemplateArgument references (see also 92 /// TemplateArgumentVisitor). 93 template <typename ImplClass, typename RetTy = void, typename... ParamTys> 94 class ConstTemplateArgumentVisitor 95 : public templateargumentvisitor::Base<llvm::make_const_ref, ImplClass, 96 RetTy, ParamTys...> {}; 97 98 } // namespace clang 99 100 #endif // LLVM_CLANG_AST_TEMPLATEARGUMENTVISITOR_H 101