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/OpenMPKinds.h"
  24 #include "clang/Basic/Sanitizers.h"
  25 #include "clang/Basic/SourceLocation.h"
  26 #include "clang/Basic/VersionTuple.h"
  27 #include "llvm/ADT/SmallVector.h"
  28 #include "llvm/ADT/StringRef.h"
  29 #include "llvm/ADT/StringSwitch.h"
  30 #include "llvm/Support/ErrorHandling.h"
  31 #include "llvm/Support/raw_ostream.h"
  32 #include <algorithm>
  33 #include <cassert>
  34
  35 namespace clang {
  36   class ASTContext;
  37   class IdentifierInfo;
  38   class ObjCInterfaceDecl;
  39   class Expr;
  40   class QualType;
  41   class FunctionDecl;
  42   class TypeSourceInfo;
  43
  44 /// Attr - This represents one attribute.
  45 class Attr {
  46 private:
  47   SourceRange Range;
  48   unsigned AttrKind : 16;
  49
  50 protected:
  51   /// An index into the spelling list of an
  52   /// attribute defined in Attr.td file.
  53   unsigned SpellingListIndex : 4;
  54   unsigned Inherited : 1;
  55   unsigned IsPackExpansion : 1;
  56   unsigned Implicit : 1;
  57   unsigned IsLateParsed : 1;
  58   unsigned DuplicatesAllowed : 1;
  59
  60   void *operator new(size_t bytes) LLVM_NOEXCEPT {
  61     llvm_unreachable("Attrs cannot be allocated with regular 'new'.");
  62   }
  63   void operator delete(void *data) LLVM_NOEXCEPT {
  64     llvm_unreachable("Attrs cannot be released with regular 'delete'.");
  65   }
  66
  67 public:
  68   // Forward so that the regular new and delete do not hide global ones.
  69   void *operator new(size_t Bytes, ASTContext &C,
  70                      size_t Alignment = 8) LLVM_NOEXCEPT {
  71     return ::operator new(Bytes, C, Alignment);
  72   }
  73   void operator delete(void *Ptr, ASTContext &C,
  74                        size_t Alignment) LLVM_NOEXCEPT {
  75     return ::operator delete(Ptr, C, Alignment);
  76   }
  77
  78 protected:
  79   Attr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex,
  80        bool IsLateParsed, bool DuplicatesAllowed)
  81     : Range(R), AttrKind(AK), SpellingListIndex(SpellingListIndex),
  82       Inherited(false), IsPackExpansion(false), Implicit(false),
  83       IsLateParsed(IsLateParsed), DuplicatesAllowed(DuplicatesAllowed) {}
  84
  85 public:
  86
  87   attr::Kind getKind() const {
  88     return static_cast<attr::Kind>(AttrKind);
  89   }
  90
  91   unsigned getSpellingListIndex() const { return SpellingListIndex; }
  92   const char *getSpelling() const;
  93
  94   SourceLocation getLocation() const { return Range.getBegin(); }
  95   SourceRange getRange() const { return Range; }
  96   void setRange(SourceRange R) { Range = R; }
  97
  98   bool isInherited() const { return Inherited; }
  99
 100   /// \brief Returns true if the attribute has been implicitly created instead
 101   /// of explicitly written by the user.
 102   bool isImplicit() const { return Implicit; }
 103   void setImplicit(bool I) { Implicit = I; }
 104
 105   void setPackExpansion(bool PE) { IsPackExpansion = PE; }
 106   bool isPackExpansion() const { return IsPackExpansion; }
 107
 108   // Clone this attribute.
 109   Attr *clone(ASTContext &C) const;
 110
 111   bool isLateParsed() const { return IsLateParsed; }
 112
 113   // Pretty print this attribute.
 114   void printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const;
 115
 116   /// \brief By default, attributes cannot be duplicated when being merged;
 117   /// however, an attribute can override this. Returns true if the attribute
 118   /// can be duplicated when merging.
 119   bool duplicatesAllowed() const { return DuplicatesAllowed; }
 120 };
 121
 122 class StmtAttr : public Attr {
 123 protected:
 124   StmtAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex,
 125                   bool IsLateParsed, bool DuplicatesAllowed)
 126       : Attr(AK, R, SpellingListIndex, IsLateParsed, DuplicatesAllowed) {}
 127
 128 public:
 129   static bool classof(const Attr *A) {
 130     return A->getKind() >= attr::FirstStmtAttr &&
 131            A->getKind() <= attr::LastStmtAttr;
 132   }
 133 };
 134
 135 class InheritableAttr : public Attr {
 136 protected:
 137   InheritableAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex,
 138                   bool IsLateParsed, bool DuplicatesAllowed)
 139       : Attr(AK, R, SpellingListIndex, IsLateParsed, DuplicatesAllowed) {}
 140
 141 public:
 142   void setInherited(bool I) { Inherited = I; }
 143
 144   // Implement isa/cast/dyncast/etc.
 145   static bool classof(const Attr *A) {
 146     return A->getKind() >= attr::FirstInheritableAttr &&
 147            A->getKind() <= attr::LastInheritableAttr;
 148   }
 149 };
 150
 151 class InheritableParamAttr : public InheritableAttr {
 152 protected:
 153   InheritableParamAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex,
 154                        bool IsLateParsed, bool DuplicatesAllowed)
 155       : InheritableAttr(AK, R, SpellingListIndex, IsLateParsed,
 156                         DuplicatesAllowed) {}
 157
 158 public:
 159   // Implement isa/cast/dyncast/etc.
 160   static bool classof(const Attr *A) {
 161     return A->getKind() >= attr::FirstInheritableParamAttr &&
 162            A->getKind() <= attr::LastInheritableParamAttr;
 163   }
 164 };
 165
 166 /// A parameter attribute which changes the argument-passing ABI rule
 167 /// for the parameter.
 168 class ParameterABIAttr : public InheritableParamAttr {
 169 protected:
 170   ParameterABIAttr(attr::Kind AK, SourceRange R,
 171                    unsigned SpellingListIndex, bool IsLateParsed,
 172                    bool DuplicatesAllowed)
 173     : InheritableParamAttr(AK, R, SpellingListIndex, IsLateParsed,
 174                            DuplicatesAllowed) {}
 175
 176 public:
 177   ParameterABI getABI() const {
 178     switch (getKind()) {
 179     case attr::SwiftContext:
 180       return ParameterABI::SwiftContext;
 181     case attr::SwiftErrorResult:
 182       return ParameterABI::SwiftErrorResult;
 183     case attr::SwiftIndirectResult:
 184       return ParameterABI::SwiftIndirectResult;
 185     default:
 186       llvm_unreachable("bad parameter ABI attribute kind");
 187     }
 188   }
 189
 190   static bool classof(const Attr *A) {
 191     return A->getKind() >= attr::FirstParameterABIAttr &&
 192            A->getKind() <= attr::LastParameterABIAttr;
 193    }
 194 };
 195
 196 #include "clang/AST/Attrs.inc"
 197
 198 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
 199                                            const Attr *At) {
 200   DB.AddTaggedVal(reinterpret_cast<intptr_t>(At),
 201                   DiagnosticsEngine::ak_attr);
 202   return DB;
 203 }
 204
 205 inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 206                                            const Attr *At) {
 207   PD.AddTaggedVal(reinterpret_cast<intptr_t>(At),
 208                   DiagnosticsEngine::ak_attr);
 209   return PD;
 210 }
 211 }  // end namespace clang
 212
 213 #endif