contrib/llvm/tools/clang/include/clang/AST/Attr.h

   1 //===--- Attr.h - Classes for representing attributes ----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file defines the Attr interface and subclasses.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_AST_ATTR_H
  15 #define LLVM_CLANG_AST_ATTR_H
  16
  17 #include "clang/AST/AttrIterator.h"
  18 #include "clang/AST/Decl.h"
  19 #include "clang/AST/Expr.h"
  20 #include "clang/AST/Type.h"
  21 #include "clang/Basic/AttrKinds.h"
  22 #include "clang/Basic/LLVM.h"
  23 #include "clang/Basic/Sanitizers.h"
  24 #include "clang/Basic/SourceLocation.h"
  25 #include "clang/Basic/VersionTuple.h"
  26 #include "llvm/ADT/SmallVector.h"
  27 #include "llvm/ADT/StringRef.h"
  28 #include "llvm/ADT/StringSwitch.h"
  29 #include "llvm/Support/ErrorHandling.h"
  30 #include "llvm/Support/raw_ostream.h"
  31 #include <algorithm>
  32 #include <cassert>
  33
  34 namespace clang {
  35   class ASTContext;
  36   class IdentifierInfo;
  37   class ObjCInterfaceDecl;
  38   class Expr;
  39   class QualType;
  40   class FunctionDecl;
  41   class TypeSourceInfo;
  42
  43 /// Attr - This represents one attribute.
  44 class Attr {
  45 private:
  46   SourceRange Range;
  47   unsigned AttrKind : 16;
  48
  49 protected:
  50   /// An index into the spelling list of an
  51   /// attribute defined in Attr.td file.
  52   unsigned SpellingListIndex : 4;
  53   bool Inherited : 1;
  54   bool IsPackExpansion : 1;
  55   bool Implicit : 1;
  56   bool IsLateParsed : 1;
  57   bool DuplicatesAllowed : 1;
  58
  59   void *operator new(size_t bytes) LLVM_NOEXCEPT {
  60     llvm_unreachable("Attrs cannot be allocated with regular 'new'.");
  61   }
  62   void operator delete(void *data) LLVM_NOEXCEPT {
  63     llvm_unreachable("Attrs cannot be released with regular 'delete'.");
  64   }
  65
  66 public:
  67   // Forward so that the regular new and delete do not hide global ones.
  68   void *operator new(size_t Bytes, ASTContext &C,
  69                      size_t Alignment = 8) LLVM_NOEXCEPT {
  70     return ::operator new(Bytes, C, Alignment);
  71   }
  72   void operator delete(void *Ptr, ASTContext &C,
  73                        size_t Alignment) LLVM_NOEXCEPT {
  74     return ::operator delete(Ptr, C, Alignment);
  75   }
  76
  77 protected:
  78   Attr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex,
  79        bool IsLateParsed, bool DuplicatesAllowed)
  80     : Range(R), AttrKind(AK), SpellingListIndex(SpellingListIndex),
  81       Inherited(false), IsPackExpansion(false), Implicit(false),
  82       IsLateParsed(IsLateParsed), DuplicatesAllowed(DuplicatesAllowed) {}
  83
  84 public:
  85
  86   attr::Kind getKind() const {
  87     return static_cast<attr::Kind>(AttrKind);
  88   }
  89
  90   unsigned getSpellingListIndex() const { return SpellingListIndex; }
  91   const char *getSpelling() const;
  92
  93   SourceLocation getLocation() const { return Range.getBegin(); }
  94   SourceRange getRange() const { return Range; }
  95   void setRange(SourceRange R) { Range = R; }
  96
  97   bool isInherited() const { return Inherited; }
  98
  99   /// \brief Returns true if the attribute has been implicitly created instead
 100   /// of explicitly written by the user.
 101   bool isImplicit() const { return Implicit; }
 102   void setImplicit(bool I) { Implicit = I; }
 103
 104   void setPackExpansion(bool PE) { IsPackExpansion = PE; }
 105   bool isPackExpansion() const { return IsPackExpansion; }
 106
 107   // Clone this attribute.
 108   Attr *clone(ASTContext &C) const;
 109
 110   bool isLateParsed() const { return IsLateParsed; }
 111
 112   // Pretty print this attribute.
 113   void printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const;
 114
 115   /// \brief By default, attributes cannot be duplicated when being merged;
 116   /// however, an attribute can override this. Returns true if the attribute
 117   /// can be duplicated when merging.
 118   bool duplicatesAllowed() const { return DuplicatesAllowed; }
 119 };
 120
 121 class InheritableAttr : public Attr {
 122 protected:
 123   InheritableAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex,
 124                   bool IsLateParsed, bool DuplicatesAllowed)
 125       : Attr(AK, R, SpellingListIndex, IsLateParsed, DuplicatesAllowed) {}
 126
 127 public:
 128   void setInherited(bool I) { Inherited = I; }
 129
 130   // Implement isa/cast/dyncast/etc.
 131   static bool classof(const Attr *A) {
 132     return A->getKind() <= attr::LAST_INHERITABLE;
 133   }
 134 };
 135
 136 class InheritableParamAttr : public InheritableAttr {
 137 protected:
 138   InheritableParamAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex,
 139                        bool IsLateParsed, bool DuplicatesAllowed)
 140       : InheritableAttr(AK, R, SpellingListIndex, IsLateParsed,
 141                         DuplicatesAllowed) {}
 142
 143 public:
 144   // Implement isa/cast/dyncast/etc.
 145   static bool classof(const Attr *A) {
 146     // Relies on relative order of enum emission with respect to MS inheritance
 147     // attrs.
 148     return A->getKind() <= attr::LAST_INHERITABLE_PARAM;
 149   }
 150 };
 151
 152 #include "clang/AST/Attrs.inc"
 153
 154 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
 155                                            const Attr *At) {
 156   DB.AddTaggedVal(reinterpret_cast<intptr_t>(At),
 157                   DiagnosticsEngine::ak_attr);
 158   return DB;
 159 }
 160
 161 inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 162                                            const Attr *At) {
 163   PD.AddTaggedVal(reinterpret_cast<intptr_t>(At),
 164                   DiagnosticsEngine::ak_attr);
 165   return PD;
 166 }
 167 }  // end namespace clang
 168
 169 #endif