1 //===- TemplateDeduction.h - C++ template argument deduction ----*- 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 // This file provides types used with Sema's template argument deduction 10 // routines. 11 // 12 //===----------------------------------------------------------------------===/ 13 #ifndef LLVM_CLANG_SEMA_TEMPLATEDEDUCTION_H 14 #define LLVM_CLANG_SEMA_TEMPLATEDEDUCTION_H 15 16 #include "clang/AST/DeclTemplate.h" 17 #include "clang/Basic/PartialDiagnostic.h" 18 #include "llvm/ADT/SmallVector.h" 19 20 namespace clang { 21 22 struct DeducedPack; 23 class TemplateArgumentList; 24 class Sema; 25 26 namespace sema { 27 28 /// \brief Provides information about an attempted template argument 29 /// deduction, whose success or failure was described by a 30 /// TemplateDeductionResult value. 31 class TemplateDeductionInfo { 32 /// \brief The deduced template argument list. 33 /// 34 TemplateArgumentList *Deduced; 35 36 /// \brief The source location at which template argument 37 /// deduction is occurring. 38 SourceLocation Loc; 39 40 /// \brief Have we suppressed an error during deduction? 41 bool HasSFINAEDiagnostic; 42 43 /// \brief Warnings (and follow-on notes) that were suppressed due to 44 /// SFINAE while performing template argument deduction. 45 SmallVector<PartialDiagnosticAt, 4> SuppressedDiagnostics; 46 47 TemplateDeductionInfo(const TemplateDeductionInfo &) = delete; 48 void operator=(const TemplateDeductionInfo &) = delete; 49 50 public: 51 TemplateDeductionInfo(SourceLocation Loc) 52 : Deduced(nullptr), Loc(Loc), HasSFINAEDiagnostic(false), 53 Expression(nullptr) {} 54 55 /// \brief Returns the location at which template argument is 56 /// occurring. 57 SourceLocation getLocation() const { 58 return Loc; 59 } 60 61 /// \brief Take ownership of the deduced template argument list. 62 TemplateArgumentList *take() { 63 TemplateArgumentList *Result = Deduced; 64 Deduced = nullptr; 65 return Result; 66 } 67 68 /// \brief Take ownership of the SFINAE diagnostic. 69 void takeSFINAEDiagnostic(PartialDiagnosticAt &PD) { 70 assert(HasSFINAEDiagnostic); 71 PD.first = SuppressedDiagnostics.front().first; 72 PD.second.swap(SuppressedDiagnostics.front().second); 73 SuppressedDiagnostics.clear(); 74 HasSFINAEDiagnostic = false; 75 } 76 77 /// \brief Provide a new template argument list that contains the 78 /// results of template argument deduction. 79 void reset(TemplateArgumentList *NewDeduced) { 80 Deduced = NewDeduced; 81 } 82 83 /// \brief Is a SFINAE diagnostic available? 84 bool hasSFINAEDiagnostic() const { 85 return HasSFINAEDiagnostic; 86 } 87 88 /// \brief Set the diagnostic which caused the SFINAE failure. 89 void addSFINAEDiagnostic(SourceLocation Loc, PartialDiagnostic PD) { 90 // Only collect the first diagnostic. 91 if (HasSFINAEDiagnostic) 92 return; 93 SuppressedDiagnostics.clear(); 94 SuppressedDiagnostics.emplace_back(Loc, std::move(PD)); 95 HasSFINAEDiagnostic = true; 96 } 97 98 /// \brief Add a new diagnostic to the set of diagnostics 99 void addSuppressedDiagnostic(SourceLocation Loc, 100 PartialDiagnostic PD) { 101 if (HasSFINAEDiagnostic) 102 return; 103 SuppressedDiagnostics.emplace_back(Loc, std::move(PD)); 104 } 105 106 /// \brief Iterator over the set of suppressed diagnostics. 107 typedef SmallVectorImpl<PartialDiagnosticAt>::const_iterator 108 diag_iterator; 109 110 /// \brief Returns an iterator at the beginning of the sequence of suppressed 111 /// diagnostics. 112 diag_iterator diag_begin() const { return SuppressedDiagnostics.begin(); } 113 114 /// \brief Returns an iterator at the end of the sequence of suppressed 115 /// diagnostics. 116 diag_iterator diag_end() const { return SuppressedDiagnostics.end(); } 117 118 /// \brief The template parameter to which a template argument 119 /// deduction failure refers. 120 /// 121 /// Depending on the result of template argument deduction, this 122 /// template parameter may have different meanings: 123 /// 124 /// TDK_Incomplete: this is the first template parameter whose 125 /// corresponding template argument was not deduced. 126 /// 127 /// TDK_Inconsistent: this is the template parameter for which 128 /// two different template argument values were deduced. 129 TemplateParameter Param; 130 131 /// \brief The first template argument to which the template 132 /// argument deduction failure refers. 133 /// 134 /// Depending on the result of the template argument deduction, 135 /// this template argument may have different meanings: 136 /// 137 /// TDK_Inconsistent: this argument is the first value deduced 138 /// for the corresponding template parameter. 139 /// 140 /// TDK_SubstitutionFailure: this argument is the template 141 /// argument we were instantiating when we encountered an error. 142 /// 143 /// TDK_DeducedMismatch: this is the parameter type, after substituting 144 /// deduced arguments. 145 /// 146 /// TDK_NonDeducedMismatch: this is the component of the 'parameter' 147 /// of the deduction, directly provided in the source code. 148 TemplateArgument FirstArg; 149 150 /// \brief The second template argument to which the template 151 /// argument deduction failure refers. 152 /// 153 /// TDK_Inconsistent: this argument is the second value deduced 154 /// for the corresponding template parameter. 155 /// 156 /// TDK_DeducedMismatch: this is the (adjusted) call argument type. 157 /// 158 /// TDK_NonDeducedMismatch: this is the mismatching component of the 159 /// 'argument' of the deduction, from which we are deducing arguments. 160 /// 161 /// FIXME: Finish documenting this. 162 TemplateArgument SecondArg; 163 164 union { 165 /// \brief The expression which caused a deduction failure. 166 /// 167 /// TDK_FailedOverloadResolution: this argument is the reference to 168 /// an overloaded function which could not be resolved to a specific 169 /// function. 170 Expr *Expression; 171 172 /// \brief The index of the function argument that caused a deduction 173 /// failure. 174 /// 175 /// TDK_DeducedMismatch: this is the index of the argument that had a 176 /// different argument type from its substituted parameter type. 177 unsigned CallArgIndex; 178 }; 179 180 /// \brief Information on packs that we're currently expanding. 181 /// 182 /// FIXME: This should be kept internal to SemaTemplateDeduction. 183 SmallVector<DeducedPack *, 8> PendingDeducedPacks; 184 }; 185 186 } // end namespace sema 187 188 /// A structure used to record information about a failed 189 /// template argument deduction, for diagnosis. 190 struct DeductionFailureInfo { 191 /// A Sema::TemplateDeductionResult. 192 unsigned Result : 8; 193 194 /// \brief Indicates whether a diagnostic is stored in Diagnostic. 195 unsigned HasDiagnostic : 1; 196 197 /// \brief Opaque pointer containing additional data about 198 /// this deduction failure. 199 void *Data; 200 201 /// \brief A diagnostic indicating why deduction failed. 202 union { 203 void *Align; 204 char Diagnostic[sizeof(PartialDiagnosticAt)]; 205 }; 206 207 /// \brief Retrieve the diagnostic which caused this deduction failure, 208 /// if any. 209 PartialDiagnosticAt *getSFINAEDiagnostic(); 210 211 /// \brief Retrieve the template parameter this deduction failure 212 /// refers to, if any. 213 TemplateParameter getTemplateParameter(); 214 215 /// \brief Retrieve the template argument list associated with this 216 /// deduction failure, if any. 217 TemplateArgumentList *getTemplateArgumentList(); 218 219 /// \brief Return the first template argument this deduction failure 220 /// refers to, if any. 221 const TemplateArgument *getFirstArg(); 222 223 /// \brief Return the second template argument this deduction failure 224 /// refers to, if any. 225 const TemplateArgument *getSecondArg(); 226 227 /// \brief Return the expression this deduction failure refers to, 228 /// if any. 229 Expr *getExpr(); 230 231 /// \brief Return the index of the call argument that this deduction 232 /// failure refers to, if any. 233 llvm::Optional<unsigned> getCallArgIndex(); 234 235 /// \brief Free any memory associated with this deduction failure. 236 void Destroy(); 237 }; 238 239 /// TemplateSpecCandidate - This is a generalization of OverloadCandidate 240 /// which keeps track of template argument deduction failure info, when 241 /// handling explicit specializations (and instantiations) of templates 242 /// beyond function overloading. 243 /// For now, assume that the candidates are non-matching specializations. 244 /// TODO: In the future, we may need to unify/generalize this with 245 /// OverloadCandidate. 246 struct TemplateSpecCandidate { 247 /// \brief The declaration that was looked up, together with its access. 248 /// Might be a UsingShadowDecl, but usually a FunctionTemplateDecl. 249 DeclAccessPair FoundDecl; 250 251 /// Specialization - The actual specialization that this candidate 252 /// represents. When NULL, this may be a built-in candidate. 253 Decl *Specialization; 254 255 /// Template argument deduction info 256 DeductionFailureInfo DeductionFailure; 257 258 void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info) { 259 FoundDecl = Found; 260 Specialization = Spec; 261 DeductionFailure = Info; 262 } 263 264 /// Diagnose a template argument deduction failure. 265 void NoteDeductionFailure(Sema &S, bool ForTakingAddress); 266 }; 267 268 /// TemplateSpecCandidateSet - A set of generalized overload candidates, 269 /// used in template specializations. 270 /// TODO: In the future, we may need to unify/generalize this with 271 /// OverloadCandidateSet. 272 class TemplateSpecCandidateSet { 273 SmallVector<TemplateSpecCandidate, 16> Candidates; 274 SourceLocation Loc; 275 // Stores whether we're taking the address of these candidates. This helps us 276 // produce better error messages when dealing with the pass_object_size 277 // attribute on parameters. 278 bool ForTakingAddress; 279 280 TemplateSpecCandidateSet( 281 const TemplateSpecCandidateSet &) = delete; 282 void operator=(const TemplateSpecCandidateSet &) = delete; 283 284 void destroyCandidates(); 285 286 public: 287 TemplateSpecCandidateSet(SourceLocation Loc, bool ForTakingAddress = false) 288 : Loc(Loc), ForTakingAddress(ForTakingAddress) {} 289 ~TemplateSpecCandidateSet() { destroyCandidates(); } 290 291 SourceLocation getLocation() const { return Loc; } 292 293 /// \brief Clear out all of the candidates. 294 /// TODO: This may be unnecessary. 295 void clear(); 296 297 typedef SmallVector<TemplateSpecCandidate, 16>::iterator iterator; 298 iterator begin() { return Candidates.begin(); } 299 iterator end() { return Candidates.end(); } 300 301 size_t size() const { return Candidates.size(); } 302 bool empty() const { return Candidates.empty(); } 303 304 /// \brief Add a new candidate with NumConversions conversion sequence slots 305 /// to the overload set. 306 TemplateSpecCandidate &addCandidate() { 307 Candidates.emplace_back(); 308 return Candidates.back(); 309 } 310 311 void NoteCandidates(Sema &S, SourceLocation Loc); 312 313 void NoteCandidates(Sema &S, SourceLocation Loc) const { 314 const_cast<TemplateSpecCandidateSet *>(this)->NoteCandidates(S, Loc); 315 } 316 }; 317 318 } // end namespace clang 319 320 #endif 321
