compilerplugins/clang/check.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #ifndef INCLUDED_COMPILERPLUGINS_CLANG_CHECK_HXX
  11 #define INCLUDED_COMPILERPLUGINS_CLANG_CHECK_HXX
  12
  13 #include <cstddef>
  14
  15 #include <clang/AST/DeclBase.h>
  16 #include <clang/AST/Decl.h>
  17 #include <clang/AST/Type.h>
  18 #include <clang/Basic/OperatorKinds.h>
  19
  20 namespace loplugin {
  21
  22 class ContextCheck;
  23 class TerminalCheck;
  24
  25 namespace detail {
  26
  27 template<std::size_t N> ContextCheck checkRecordDecl(
  28     clang::Decl const * decl, clang::TagTypeKind tag, char const (& id)[N]);
  29
  30 }
  31
  32 class TypeCheck {
  33 public:
  34     explicit TypeCheck(clang::QualType type): type_(type) {}
  35
  36     explicit operator bool() const { return !type_.isNull(); }
  37
  38     TypeCheck Const() const;
  39
  40     TerminalCheck Char() const;
  41
  42     TerminalCheck AnyBoolean() const;
  43
  44     TypeCheck Pointer() const;
  45
  46     TypeCheck LvalueReference() const;
  47
  48     template<std::size_t N> inline ContextCheck Class(char const (& id)[N])
  49         const;
  50
  51     TypeCheck Typedef() const;
  52
  53     template<std::size_t N> inline ContextCheck Typedef(char const (& id)[N])
  54         const;
  55
  56     TypeCheck NotSubstTemplateTypeParmType() const;
  57
  58 private:
  59     TypeCheck() = default;
  60
  61     clang::QualType const type_;
  62 };
  63
  64 class DeclCheck {
  65 public:
  66     explicit DeclCheck(clang::Decl const * decl): decl_(decl) {}
  67
  68     explicit operator bool() const { return decl_ != nullptr; }
  69
  70     template<std::size_t N> inline ContextCheck Class(char const (& id)[N])
  71         const;
  72
  73     template<std::size_t N> inline ContextCheck Struct(char const (& id)[N])
  74         const;
  75
  76     template<std::size_t N> inline ContextCheck Function(char const (& id)[N])
  77         const;
  78
  79     ContextCheck Operator(clang::OverloadedOperatorKind op) const;
  80
  81     template<std::size_t N> inline ContextCheck Var(char const (& id)[N])
  82         const;
  83
  84     ContextCheck MemberFunction() const;
  85
  86 private:
  87     clang::Decl const * const decl_;
  88 };
  89
  90 class ContextCheck {
  91 public:
  92     explicit operator bool() const { return context_ != nullptr; }
  93
  94     TerminalCheck GlobalNamespace() const;
  95
  96     template<std::size_t N> inline ContextCheck Namespace(
  97         char const (& id)[N]) const;
  98
  99     TerminalCheck StdNamespace() const;
 100
 101     ContextCheck AnonymousNamespace() const;
 102
 103     template<std::size_t N> inline ContextCheck Class(char const (& id)[N])
 104         const;
 105
 106     template<std::size_t N> inline ContextCheck Struct(char const (& id)[N])
 107         const;
 108
 109 private:
 110     friend DeclCheck;
 111     friend TypeCheck;
 112     template<std::size_t N> friend ContextCheck detail::checkRecordDecl(
 113         clang::Decl const * decl, clang::TagTypeKind tag, char const (& id)[N]);
 114
 115     explicit ContextCheck(clang::DeclContext const * context = nullptr):
 116         context_(context) {}
 117
 118     clang::DeclContext const * const context_;
 119 };
 120
 121 class TerminalCheck {
 122 public:
 123     explicit operator bool() const { return satisfied_; }
 124
 125 private:
 126     friend ContextCheck;
 127     friend TypeCheck;
 128
 129     explicit TerminalCheck(bool satisfied): satisfied_(satisfied) {}
 130
 131     bool const satisfied_;
 132 };
 133
 134 namespace detail {
 135
 136 template<std::size_t N> ContextCheck checkRecordDecl(
 137     clang::Decl const * decl, clang::TagTypeKind tag, char const (& id)[N])
 138 {
 139     auto r = llvm::dyn_cast_or_null<clang::RecordDecl>(decl);
 140     if (r != nullptr && r->getTagKind() == tag) {
 141         auto const i = r->getIdentifier();
 142         if (i != nullptr && i->isStr(id)) {
 143             return ContextCheck(r->getDeclContext());
 144         }
 145     }
 146     return ContextCheck();
 147 }
 148
 149 }
 150
 151 template<std::size_t N> ContextCheck TypeCheck::Class(char const (& id)[N])
 152     const
 153 {
 154     if (!type_.isNull()) {
 155         auto const t = type_->getAs<clang::RecordType>();
 156         if (t != nullptr) {
 157             return detail::checkRecordDecl(t->getDecl(), clang::TTK_Class, id);
 158         }
 159     }
 160     return ContextCheck();
 161 }
 162
 163 template<std::size_t N> ContextCheck TypeCheck::Typedef(char const (& id)[N])
 164     const
 165 {
 166     if (!type_.isNull()) {
 167         if (auto const t = type_->getAs<clang::TypedefType>()) {
 168             auto const d = t->getDecl();
 169             auto const i = d->getIdentifier();
 170             assert(i != nullptr);
 171             if (i->isStr(id)) {
 172                 return ContextCheck(d->getDeclContext());
 173             }
 174         }
 175     }
 176     return ContextCheck();
 177 }
 178
 179 template<std::size_t N> ContextCheck DeclCheck::Class(char const (& id)[N])
 180     const
 181 {
 182     return detail::checkRecordDecl(decl_, clang::TTK_Class, id);
 183 }
 184
 185 template<std::size_t N> ContextCheck DeclCheck::Struct(char const (& id)[N])
 186     const
 187 {
 188     return detail::checkRecordDecl(decl_, clang::TTK_Struct, id);
 189 }
 190
 191 template<std::size_t N> ContextCheck DeclCheck::Function(char const (& id)[N])
 192     const
 193 {
 194     auto f = llvm::dyn_cast_or_null<clang::FunctionDecl>(decl_);
 195     if (f != nullptr) {
 196         auto const i = f->getIdentifier();
 197         if (i != nullptr && i->isStr(id)) {
 198             return ContextCheck(f->getDeclContext());
 199         }
 200     }
 201     return ContextCheck();
 202 }
 203
 204 template<std::size_t N> ContextCheck DeclCheck::Var(char const (& id)[N])
 205     const
 206 {
 207     auto f = llvm::dyn_cast_or_null<clang::VarDecl>(decl_);
 208     if (f != nullptr) {
 209         auto const i = f->getIdentifier();
 210         if (i != nullptr && i->isStr(id)) {
 211             return ContextCheck(f->getDeclContext());
 212         }
 213     }
 214     return ContextCheck();
 215 }
 216
 217 template<std::size_t N> ContextCheck ContextCheck::Namespace(
 218     char const (& id)[N]) const
 219 {
 220     if (context_) {
 221         auto n = llvm::dyn_cast<clang::NamespaceDecl>(context_);
 222         if (n != nullptr) {
 223             auto const i = n->getIdentifier();
 224             if (i != nullptr && i->isStr(id)) {
 225                 return ContextCheck(n->getParent());
 226             }
 227         }
 228     }
 229     return ContextCheck();
 230 }
 231
 232 template<std::size_t N> ContextCheck ContextCheck::Class(char const (& id)[N])
 233     const
 234 {
 235     return detail::checkRecordDecl(
 236         llvm::dyn_cast_or_null<clang::Decl>(context_), clang::TTK_Class, id);
 237 }
 238
 239 template<std::size_t N> ContextCheck ContextCheck::Struct(char const (& id)[N])
 240     const
 241 {
 242     return detail::checkRecordDecl(
 243         llvm::dyn_cast_or_null<clang::Decl>(context_), clang::TTK_Struct, id);
 244 }
 245
 246 }
 247
 248 #endif
 249
 250 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */