1 //==- DependentDiagnostic.h - Dependently-generated diagnostics --*- 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 interfaces for diagnostics which may or may 10 // fire based on how a template is instantiated. 11 // 12 // At the moment, the only consumer of this interface is access 13 // control. 14 // 15 //===----------------------------------------------------------------------===// 16 17 #ifndef LLVM_CLANG_AST_DEPENDENTDIAGNOSTIC_H 18 #define LLVM_CLANG_AST_DEPENDENTDIAGNOSTIC_H 19 20 #include "clang/AST/DeclBase.h" 21 #include "clang/AST/DeclContextInternals.h" 22 #include "clang/AST/Type.h" 23 #include "clang/Basic/PartialDiagnostic.h" 24 #include "clang/Basic/SourceLocation.h" 25 #include "clang/Basic/Specifiers.h" 26 #include <cassert> 27 #include <iterator> 28 29 namespace clang { 30 31 class ASTContext; 32 class CXXRecordDecl; 33 class NamedDecl; 34 35 /// A dependently-generated diagnostic. 36 class DependentDiagnostic { 37 public: 38 enum AccessNonce { Access = 0 }; 39 40 static DependentDiagnostic *Create(ASTContext &Context, 41 DeclContext *Parent, 42 AccessNonce _, 43 SourceLocation Loc, 44 bool IsMemberAccess, 45 AccessSpecifier AS, 46 NamedDecl *TargetDecl, 47 CXXRecordDecl *NamingClass, 48 QualType BaseObjectType, 49 const PartialDiagnostic &PDiag) { 50 DependentDiagnostic *DD = Create(Context, Parent, PDiag); 51 DD->AccessData.Loc = Loc; 52 DD->AccessData.IsMember = IsMemberAccess; 53 DD->AccessData.Access = AS; 54 DD->AccessData.TargetDecl = TargetDecl; 55 DD->AccessData.NamingClass = NamingClass; 56 DD->AccessData.BaseObjectType = BaseObjectType.getAsOpaquePtr(); 57 return DD; 58 } 59 60 unsigned getKind() const { 61 return Access; 62 } 63 64 bool isAccessToMember() const { 65 assert(getKind() == Access); 66 return AccessData.IsMember; 67 } 68 69 AccessSpecifier getAccess() const { 70 assert(getKind() == Access); 71 return AccessSpecifier(AccessData.Access); 72 } 73 74 SourceLocation getAccessLoc() const { 75 assert(getKind() == Access); 76 return AccessData.Loc; 77 } 78 79 NamedDecl *getAccessTarget() const { 80 assert(getKind() == Access); 81 return AccessData.TargetDecl; 82 } 83 84 NamedDecl *getAccessNamingClass() const { 85 assert(getKind() == Access); 86 return AccessData.NamingClass; 87 } 88 89 QualType getAccessBaseObjectType() const { 90 assert(getKind() == Access); 91 return QualType::getFromOpaquePtr(AccessData.BaseObjectType); 92 } 93 94 const PartialDiagnostic &getDiagnostic() const { 95 return Diag; 96 } 97 98 private: 99 friend class DeclContext::ddiag_iterator; 100 friend class DependentStoredDeclsMap; 101 102 DependentDiagnostic(const PartialDiagnostic &PDiag, 103 DiagnosticStorage *Storage) 104 : Diag(PDiag, Storage) {} 105 106 static DependentDiagnostic *Create(ASTContext &Context, 107 DeclContext *Parent, 108 const PartialDiagnostic &PDiag); 109 110 DependentDiagnostic *NextDiagnostic; 111 112 PartialDiagnostic Diag; 113 114 struct { 115 SourceLocation Loc; 116 unsigned Access : 2; 117 unsigned IsMember : 1; 118 NamedDecl *TargetDecl; 119 CXXRecordDecl *NamingClass; 120 void *BaseObjectType; 121 } AccessData; 122 }; 123 124 /// An iterator over the dependent diagnostics in a dependent context. 125 class DeclContext::ddiag_iterator { 126 public: 127 ddiag_iterator() = default; 128 explicit ddiag_iterator(DependentDiagnostic *Ptr) : Ptr(Ptr) {} 129 130 using value_type = DependentDiagnostic *; 131 using reference = DependentDiagnostic *; 132 using pointer = DependentDiagnostic *; 133 using difference_type = int; 134 using iterator_category = std::forward_iterator_tag; 135 136 reference operator*() const { return Ptr; } 137 138 ddiag_iterator &operator++() { 139 assert(Ptr && "attempt to increment past end of diag list"); 140 Ptr = Ptr->NextDiagnostic; 141 return *this; 142 } 143 144 ddiag_iterator operator++(int) { 145 ddiag_iterator tmp = *this; 146 ++*this; 147 return tmp; 148 } 149 150 bool operator==(ddiag_iterator Other) const { 151 return Ptr == Other.Ptr; 152 } 153 154 bool operator!=(ddiag_iterator Other) const { 155 return Ptr != Other.Ptr; 156 } 157 158 ddiag_iterator &operator+=(difference_type N) { 159 assert(N >= 0 && "cannot rewind a DeclContext::ddiag_iterator"); 160 while (N--) 161 ++*this; 162 return *this; 163 } 164 165 ddiag_iterator operator+(difference_type N) const { 166 ddiag_iterator tmp = *this; 167 tmp += N; 168 return tmp; 169 } 170 171 private: 172 DependentDiagnostic *Ptr = nullptr; 173 }; 174 175 inline DeclContext::ddiag_range DeclContext::ddiags() const { 176 assert(isDependentContext() 177 && "cannot iterate dependent diagnostics of non-dependent context"); 178 const DependentStoredDeclsMap *Map 179 = static_cast<DependentStoredDeclsMap*>(getPrimaryContext()->getLookupPtr()); 180 181 if (!Map) 182 // Return an empty range using the always-end default constructor. 183 return ddiag_range(ddiag_iterator(), ddiag_iterator()); 184 185 return ddiag_range(ddiag_iterator(Map->FirstDiagnostic), ddiag_iterator()); 186 } 187 188 } // namespace clang 189 190 #endif // LLVM_CLANG_AST_DEPENDENTDIAGNOSTIC_H 191