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 TypeCheck(clang::TypeDecl const * decl): type_(decl->getTypeForDecl(), 0) {}
  37
  38     explicit operator bool() const { return !type_.isNull(); }
  39
  40     TypeCheck NonConst() const;
  41
  42     TypeCheck NonConstVolatile() const;
  43
  44     TypeCheck Const() const;
  45
  46     TypeCheck Volatile() const;
  47
  48     TypeCheck ConstVolatile() const;
  49
  50     TerminalCheck Void() const;
  51
  52     TerminalCheck Char() const;
  53
  54     TerminalCheck AnyBoolean() const;
  55
  56     TypeCheck Pointer() const;
  57
  58     TerminalCheck Enum() const;
  59
  60     TypeCheck LvalueReference() const;
  61
  62     template<std::size_t N> inline ContextCheck Class(char const (& id)[N])
  63         const;
  64
  65     template<std::size_t N> inline ContextCheck Struct(char const (& id)[N])
  66         const;
  67
  68     TypeCheck Typedef() const;
  69
  70     template<std::size_t N> inline ContextCheck Typedef(char const (& id)[N])
  71         const;
  72
  73     TypeCheck NotSubstTemplateTypeParmType() const;
  74
  75 private:
  76     TypeCheck() = default;
  77
  78     clang::QualType const type_{};
  79 };
  80
  81 class DeclCheck {
  82 public:
  83     explicit DeclCheck(clang::Decl const * decl): decl_(decl) {}
  84
  85     explicit operator bool() const { return decl_ != nullptr; }
  86
  87     template<std::size_t N> inline ContextCheck Class(char const (& id)[N])
  88         const;
  89
  90     template<std::size_t N> inline ContextCheck Struct(char const (& id)[N])
  91         const;
  92
  93     template<std::size_t N> inline ContextCheck Union(char const (& id)[N])
  94         const;
  95
  96     template<std::size_t N> inline ContextCheck Function(char const (& id)[N])
  97         const;
  98
  99     ContextCheck Operator(clang::OverloadedOperatorKind op) const;
 100
 101     template<std::size_t N> inline ContextCheck Var(char const (& id)[N])
 102         const;
 103
 104     ContextCheck MemberFunction() const;
 105
 106 private:
 107     clang::Decl const * const decl_;
 108 };
 109
 110 class ContextCheck {
 111 public:
 112     explicit operator bool() const { return context_ != nullptr; }
 113
 114     TerminalCheck GlobalNamespace() const;
 115
 116     template<std::size_t N> inline ContextCheck Namespace(
 117         char const (& id)[N]) const;
 118
 119     TerminalCheck StdNamespace() const;
 120
 121     ContextCheck AnonymousNamespace() const;
 122
 123     template<std::size_t N> inline ContextCheck Class(char const (& id)[N])
 124         const;
 125
 126     template<std::size_t N> inline ContextCheck Struct(char const (& id)[N])
 127         const;
 128
 129 private:
 130     friend DeclCheck;
 131     friend TypeCheck;
 132     template<std::size_t N> friend ContextCheck detail::checkRecordDecl(
 133         clang::Decl const * decl, clang::TagTypeKind tag, char const (& id)[N]);
 134
 135     explicit ContextCheck(clang::DeclContext const * context = nullptr):
 136         context_(context) {}
 137
 138     clang::DeclContext const * const context_;
 139 };
 140
 141 class TerminalCheck {
 142 public:
 143     explicit operator bool() const { return satisfied_; }
 144
 145 private:
 146     friend ContextCheck;
 147     friend TypeCheck;
 148
 149     explicit TerminalCheck(bool satisfied): satisfied_(satisfied) {}
 150
 151     bool const satisfied_;
 152 };
 153
 154 namespace detail {
 155
 156 template<std::size_t N> ContextCheck checkRecordDecl(
 157     clang::Decl const * decl, clang::TagTypeKind tag, char const (& id)[N])
 158 {
 159     auto r = llvm::dyn_cast_or_null<clang::RecordDecl>(decl);
 160     if (r != nullptr && r->getTagKind() == tag) {
 161         auto const i = r->getIdentifier();
 162         if (i != nullptr && i->isStr(id)) {
 163             return ContextCheck(r->getDeclContext());
 164         }
 165     }
 166     return ContextCheck();
 167 }
 168
 169 }
 170
 171 template<std::size_t N> ContextCheck TypeCheck::Class(char const (& id)[N])
 172     const
 173 {
 174     if (!type_.isNull()) {
 175         auto const t = type_->getAs<clang::RecordType>();
 176         if (t != nullptr) {
 177             return detail::checkRecordDecl(t->getDecl(), clang::TTK_Class, id);
 178         }
 179     }
 180     return ContextCheck();
 181 }
 182
 183 template<std::size_t N> ContextCheck TypeCheck::Struct(char const (& id)[N])
 184     const
 185 {
 186     if (!type_.isNull()) {
 187         auto const t = type_->getAs<clang::RecordType>();
 188         if (t != nullptr) {
 189             return detail::checkRecordDecl(t->getDecl(), clang::TTK_Struct, id);
 190         }
 191     }
 192     return ContextCheck();
 193 }
 194
 195 template<std::size_t N> ContextCheck TypeCheck::Typedef(char const (& id)[N])
 196     const
 197 {
 198     if (!type_.isNull()) {
 199         if (auto const t = type_->getAs<clang::TypedefType>()) {
 200             auto const d = t->getDecl();
 201             auto const i = d->getIdentifier();
 202             assert(i != nullptr);
 203             if (i->isStr(id)) {
 204                 return ContextCheck(d->getDeclContext());
 205             }
 206         }
 207     }
 208     return ContextCheck();
 209 }
 210
 211 template<std::size_t N> ContextCheck DeclCheck::Class(char const (& id)[N])
 212     const
 213 {
 214     return detail::checkRecordDecl(decl_, clang::TTK_Class, id);
 215 }
 216
 217 template<std::size_t N> ContextCheck DeclCheck::Struct(char const (& id)[N])
 218     const
 219 {
 220     return detail::checkRecordDecl(decl_, clang::TTK_Struct, id);
 221 }
 222
 223 template<std::size_t N> ContextCheck DeclCheck::Union(char const (& id)[N])
 224     const
 225 {
 226     return detail::checkRecordDecl(decl_, clang::TTK_Union, id);
 227 }
 228
 229 template<std::size_t N> ContextCheck DeclCheck::Function(char const (& id)[N])
 230     const
 231 {
 232     auto f = llvm::dyn_cast_or_null<clang::FunctionDecl>(decl_);
 233     if (f != nullptr) {
 234         auto const i = f->getIdentifier();
 235         if (i != nullptr && i->isStr(id)) {
 236             return ContextCheck(f->getDeclContext());
 237         }
 238     }
 239     return ContextCheck();
 240 }
 241
 242 template<std::size_t N> ContextCheck DeclCheck::Var(char const (& id)[N])
 243     const
 244 {
 245     auto f = llvm::dyn_cast_or_null<clang::VarDecl>(decl_);
 246     if (f != nullptr) {
 247         auto const i = f->getIdentifier();
 248         if (i != nullptr && i->isStr(id)) {
 249             return ContextCheck(f->getDeclContext());
 250         }
 251     }
 252     return ContextCheck();
 253 }
 254
 255 template<std::size_t N> ContextCheck ContextCheck::Namespace(
 256     char const (& id)[N]) const
 257 {
 258     if (context_) {
 259         auto n = llvm::dyn_cast<clang::NamespaceDecl>(context_);
 260         if (n != nullptr) {
 261             auto const i = n->getIdentifier();
 262             if (i != nullptr && i->isStr(id)) {
 263                 return ContextCheck(n->getParent());
 264             }
 265         }
 266     }
 267     return ContextCheck();
 268 }
 269
 270 template<std::size_t N> ContextCheck ContextCheck::Class(char const (& id)[N])
 271     const
 272 {
 273     return detail::checkRecordDecl(
 274         llvm::dyn_cast_or_null<clang::Decl>(context_), clang::TTK_Class, id);
 275 }
 276
 277 template<std::size_t N> ContextCheck ContextCheck::Struct(char const (& id)[N])
 278     const
 279 {
 280     return detail::checkRecordDecl(
 281         llvm::dyn_cast_or_null<clang::Decl>(context_), clang::TTK_Struct, id);
 282 }
 283
 284 bool isExtraWarnUnusedType(clang::QualType type);
 285
 286 bool isOkToRemoveArithmeticCast(
 287     clang::ASTContext & context, clang::QualType t1, clang::QualType t2,
 288     const clang::Expr* subExpr);
 289
 290 }
 291
 292 #endif
 293
 294 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */