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