Coverage Report

Created: 2020-09-19 12:23

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/AST/TemplateArgumentVisitor.h
Line
Count
Source (jump to first uncovered line)
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
883
  case TemplateArgument::NAME:                                                 \
30
883
    return static_cast<ImplClass *>(this)->Visit##NAME##TemplateArgument(      \
31
883
        TA, std::forward<ParamTys>(P)...)
32
33
883
  RetTy Visit(REF(TemplateArgument) TA, ParamTys... P) {
34
883
    switch (TA.getKind()) {
35
0
      DISPATCH(Null);
36
583
      DISPATCH(Type);
37
10
      DISPATCH(Declaration);
38
4
      DISPATCH(NullPtr);
39
136
      DISPATCH(Integral);
40
28
      DISPATCH(Template);
41
0
      DISPATCH(TemplateExpansion);
42
78
      DISPATCH(Expression);
43
44
      DISPATCH(Pack);
44
883
    }
45
883
    
llvm_unreachable0
("TemplateArgument is not covered in switch!");
46
883
  }
clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::ASTDumper, void>::Visit(clang::TemplateArgument const&)
Line
Count
Source
33
433
  RetTy Visit(REF(TemplateArgument) TA, ParamTys... P) {
34
433
    switch (TA.getKind()) {
35
0
      DISPATCH(Null);
36
283
      DISPATCH(Type);
37
5
      DISPATCH(Declaration);
38
2
      DISPATCH(NullPtr);
39
68
      DISPATCH(Integral);
40
14
      DISPATCH(Template);
41
0
      DISPATCH(TemplateExpansion);
42
39
      DISPATCH(Expression);
43
22
      DISPATCH(Pack);
44
433
    }
45
0
    llvm_unreachable("TemplateArgument is not covered in switch!");
46
  }
clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::JSONDumper, void>::Visit(clang::TemplateArgument const&)
Line
Count
Source
33
7
  RetTy Visit(REF(TemplateArgument) TA, ParamTys... P) {
34
7
    switch (TA.getKind()) {
35
0
      DISPATCH(Null);
36
7
      DISPATCH(Type);
37
0
      DISPATCH(Declaration);
38
0
      DISPATCH(NullPtr);
39
0
      DISPATCH(Integral);
40
0
      DISPATCH(Template);
41
0
      DISPATCH(TemplateExpansion);
42
0
      DISPATCH(Expression);
43
0
      DISPATCH(Pack);
44
7
    }
45
0
    llvm_unreachable("TemplateArgument is not covered in switch!");
46
  }
clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::JSONNodeDumper, void>::Visit(clang::TemplateArgument const&)
Line
Count
Source
33
10
  RetTy Visit(REF(TemplateArgument) TA, ParamTys... P) {
34
10
    switch (TA.getKind()) {
35
0
      DISPATCH(Null);
36
10
      DISPATCH(Type);
37
0
      DISPATCH(Declaration);
38
0
      DISPATCH(NullPtr);
39
0
      DISPATCH(Integral);
40
0
      DISPATCH(Template);
41
0
      DISPATCH(TemplateExpansion);
42
0
      DISPATCH(Expression);
43
0
      DISPATCH(Pack);
44
10
    }
45
0
    llvm_unreachable("TemplateArgument is not covered in switch!");
46
  }
clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::TextNodeDumper, void>::Visit(clang::TemplateArgument const&)
Line
Count
Source
33
433
  RetTy Visit(REF(TemplateArgument) TA, ParamTys... P) {
34
433
    switch (TA.getKind()) {
35
0
      DISPATCH(Null);
36
283
      DISPATCH(Type);
37
5
      DISPATCH(Declaration);
38
2
      DISPATCH(NullPtr);
39
68
      DISPATCH(Integral);
40
14
      DISPATCH(Template);
41
0
      DISPATCH(TemplateExpansion);
42
39
      DISPATCH(Expression);
43
22
      DISPATCH(Pack);
44
433
    }
45
0
    llvm_unreachable("TemplateArgument is not covered in switch!");
46
  }
47
48
  // If the implementation chooses not to implement a certain visit
49
  // method, fall back to the parent.
50
51
#define VISIT_METHOD(CATEGORY)                                                 \
52
  RetTy Visit##CATEGORY##TemplateArgument(REF(TemplateArgument) TA,            \
53
89
                                          ParamTys... P) {                     \
54
89
    return VisitTemplateArgument(TA, std::forward<ParamTys>(P)...);            \
55
89
  }
Unexecuted instantiation: clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::ASTDumper, void>::VisitNullTemplateArgument(clang::TemplateArgument const&)
clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::ASTDumper, void>::VisitDeclarationTemplateArgument(clang::TemplateArgument const&)
Line
Count
Source
53
5
                                          ParamTys... P) {                     \
54
5
    return VisitTemplateArgument(TA, std::forward<ParamTys>(P)...);            \
55
5
  }
clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::ASTDumper, void>::VisitNullPtrTemplateArgument(clang::TemplateArgument const&)
Line
Count
Source
53
2
                                          ParamTys... P) {                     \
54
2
    return VisitTemplateArgument(TA, std::forward<ParamTys>(P)...);            \
55
2
  }
clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::ASTDumper, void>::VisitIntegralTemplateArgument(clang::TemplateArgument const&)
Line
Count
Source
53
68
                                          ParamTys... P) {                     \
54
68
    return VisitTemplateArgument(TA, std::forward<ParamTys>(P)...);            \
55
68
  }
clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::ASTDumper, void>::VisitTemplateTemplateArgument(clang::TemplateArgument const&)
Line
Count
Source
53
14
                                          ParamTys... P) {                     \
54
14
    return VisitTemplateArgument(TA, std::forward<ParamTys>(P)...);            \
55
14
  }
Unexecuted instantiation: clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::ASTDumper, void>::VisitTemplateExpansionTemplateArgument(clang::TemplateArgument const&)
Unexecuted instantiation: clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::JSONDumper, void>::VisitNullTemplateArgument(clang::TemplateArgument const&)
Unexecuted instantiation: clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::JSONDumper, void>::VisitDeclarationTemplateArgument(clang::TemplateArgument const&)
Unexecuted instantiation: clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::JSONDumper, void>::VisitNullPtrTemplateArgument(clang::TemplateArgument const&)
Unexecuted instantiation: clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::JSONDumper, void>::VisitIntegralTemplateArgument(clang::TemplateArgument const&)
Unexecuted instantiation: clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::JSONDumper, void>::VisitTemplateTemplateArgument(clang::TemplateArgument const&)
Unexecuted instantiation: clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::JSONDumper, void>::VisitTemplateExpansionTemplateArgument(clang::TemplateArgument const&)
56
57
  VISIT_METHOD(Null);
58
  VISIT_METHOD(Type);
59
  VISIT_METHOD(Declaration);
60
  VISIT_METHOD(NullPtr);
61
  VISIT_METHOD(Integral);
62
  VISIT_METHOD(Template);
63
  VISIT_METHOD(TemplateExpansion);
64
  VISIT_METHOD(Expression);
65
  VISIT_METHOD(Pack);
66
67
89
  RetTy VisitTemplateArgument(REF(TemplateArgument), ParamTys...) {
68
89
    return RetTy();
69
89
  }
clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::ASTDumper, void>::VisitTemplateArgument(clang::TemplateArgument const&)
Line
Count
Source
67
89
  RetTy VisitTemplateArgument(REF(TemplateArgument), ParamTys...) {
68
89
    return RetTy();
69
89
  }
Unexecuted instantiation: clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::JSONDumper, void>::VisitTemplateArgument(clang::TemplateArgument const&)
Unexecuted instantiation: clang::templateargumentvisitor::Base<llvm::make_const_ref, clang::TextNodeDumper, void>::VisitTemplateArgument(clang::TemplateArgument const&)
70
71
#undef REF
72
#undef DISPATCH
73
#undef VISIT_METHOD
74
};
75
76
} // namespace templateargumentvisitor
77
78
/// A simple visitor class that helps create template argument visitors.
79
///
80
/// This class does not preserve constness of TemplateArgument references (see
81
/// also ConstTemplateArgumentVisitor).
82
template <typename ImplClass, typename RetTy = void, typename... ParamTys>
83
class TemplateArgumentVisitor
84
    : public templateargumentvisitor::Base<std::add_lvalue_reference, ImplClass,
85
                                           RetTy, ParamTys...> {};
86
87
/// A simple visitor class that helps create template argument visitors.
88
///
89
/// This class preserves constness of TemplateArgument references (see also
90
/// TemplateArgumentVisitor).
91
template <typename ImplClass, typename RetTy = void, typename... ParamTys>
92
class ConstTemplateArgumentVisitor
93
    : public templateargumentvisitor::Base<llvm::make_const_ref, ImplClass,
94
                                           RetTy, ParamTys...> {};
95
96
} // namespace clang
97
98
#endif // LLVM_CLANG_AST_TEMPLATEARGUMENTVISITOR_H