clang  3.7.0
TemplateDeduction.h
Go to the documentation of this file.
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"
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.
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 
48  void operator=(const TemplateDeductionInfo &) = delete;
49 
50 public:
52  : Deduced(nullptr), Loc(Loc), HasSFINAEDiagnostic(false),
53  Expression(nullptr) {}
54 
55  /// \brief Returns the location at which template argument is
56  /// occurring.
58  return Loc;
59  }
60 
61  /// \brief Take ownership of the deduced template argument list.
63  TemplateArgumentList *Result = Deduced;
64  Deduced = nullptr;
65  return Result;
66  }
67 
68  /// \brief Take ownership of the SFINAE diagnostic.
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.
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
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.
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.
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_NonDeducedMismatch: this is the component of the 'parameter'
144  /// of the deduction, directly provided in the source code.
146 
147  /// \brief The second template argument to which the template
148  /// argument deduction failure refers.
149  ///
150  /// TDK_NonDeducedMismatch: this is the mismatching component of the
151  /// 'argument' of the deduction, from which we are deducing arguments.
152  ///
153  /// FIXME: Finish documenting this.
155 
156  /// \brief The expression which caused a deduction failure.
157  ///
158  /// TDK_FailedOverloadResolution: this argument is the reference to
159  /// an overloaded function which could not be resolved to a specific
160  /// function.
162 
163  /// \brief Information on packs that we're currently expanding.
164  ///
165  /// FIXME: This should be kept internal to SemaTemplateDeduction.
167 };
168 
169 } // end namespace sema
170 
171 /// A structure used to record information about a failed
172 /// template argument deduction, for diagnosis.
174  /// A Sema::TemplateDeductionResult.
175  unsigned Result : 8;
176 
177  /// \brief Indicates whether a diagnostic is stored in Diagnostic.
178  unsigned HasDiagnostic : 1;
179 
180  /// \brief Opaque pointer containing additional data about
181  /// this deduction failure.
182  void *Data;
183 
184  /// \brief A diagnostic indicating why deduction failed.
185  union {
186  void *Align;
188  };
189 
190  /// \brief Retrieve the diagnostic which caused this deduction failure,
191  /// if any.
193 
194  /// \brief Retrieve the template parameter this deduction failure
195  /// refers to, if any.
197 
198  /// \brief Retrieve the template argument list associated with this
199  /// deduction failure, if any.
201 
202  /// \brief Return the first template argument this deduction failure
203  /// refers to, if any.
204  const TemplateArgument *getFirstArg();
205 
206  /// \brief Return the second template argument this deduction failure
207  /// refers to, if any.
209 
210  /// \brief Return the expression this deduction failure refers to,
211  /// if any.
212  Expr *getExpr();
213 
214  /// \brief Free any memory associated with this deduction failure.
215  void Destroy();
216 };
217 
218 /// TemplateSpecCandidate - This is a generalization of OverloadCandidate
219 /// which keeps track of template argument deduction failure info, when
220 /// handling explicit specializations (and instantiations) of templates
221 /// beyond function overloading.
222 /// For now, assume that the candidates are non-matching specializations.
223 /// TODO: In the future, we may need to unify/generalize this with
224 /// OverloadCandidate.
226  /// Specialization - The actual specialization that this candidate
227  /// represents. When NULL, this may be a built-in candidate.
229 
230  /// Template argument deduction info
232 
233  void set(Decl *Spec, DeductionFailureInfo Info) {
234  Specialization = Spec;
235  DeductionFailure = Info;
236  }
237 
238  /// Diagnose a template argument deduction failure.
239  void NoteDeductionFailure(Sema &S);
240 };
241 
242 /// TemplateSpecCandidateSet - A set of generalized overload candidates,
243 /// used in template specializations.
244 /// TODO: In the future, we may need to unify/generalize this with
245 /// OverloadCandidateSet.
248  SourceLocation Loc;
249 
251  const TemplateSpecCandidateSet &) = delete;
252  void operator=(const TemplateSpecCandidateSet &) = delete;
253 
254  void destroyCandidates();
255 
256 public:
258  ~TemplateSpecCandidateSet() { destroyCandidates(); }
259 
260  SourceLocation getLocation() const { return Loc; }
261 
262  /// \brief Clear out all of the candidates.
263  /// TODO: This may be unnecessary.
264  void clear();
265 
267  iterator begin() { return Candidates.begin(); }
268  iterator end() { return Candidates.end(); }
269 
270  size_t size() const { return Candidates.size(); }
271  bool empty() const { return Candidates.empty(); }
272 
273  /// \brief Add a new candidate with NumConversions conversion sequence slots
274  /// to the overload set.
276  Candidates.emplace_back();
277  return Candidates.back();
278  }
279 
280  void NoteCandidates(Sema &S, SourceLocation Loc);
281 
282  void NoteCandidates(Sema &S, SourceLocation Loc) const {
283  const_cast<TemplateSpecCandidateSet *>(this)->NoteCandidates(S, Loc);
284  }
285 };
286 
287 } // end namespace clang
288 
289 #endif
SmallVector< TemplateSpecCandidate, 16 >::iterator iterator
const TemplateArgument * getSecondArg()
Return the second template argument this deduction failure refers to, if any.
void NoteCandidates(Sema &S, SourceLocation Loc) const
Provides information about an attempted template argument deduction, whose success or failure was des...
void clear()
Clear out all of the candidates. TODO: This may be unnecessary.
Defines the C++ template declaration subclasses.
Expr * getExpr()
Return the expression this deduction failure refers to, if any.
void addSuppressedDiagnostic(SourceLocation Loc, PartialDiagnostic PD)
Add a new diagnostic to the set of diagnostics.
TemplateParameter Param
The template parameter to which a template argument deduction failure refers.
void Destroy()
Free any memory associated with this deduction failure.
TemplateParameter getTemplateParameter()
Retrieve the template parameter this deduction failure refers to, if any.
diag_iterator diag_end() const
Returns an iterator at the end of the sequence of suppressed diagnostics.
DeductionFailureInfo DeductionFailure
Template argument deduction info.
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:258
void reset(TemplateArgumentList *NewDeduced)
Provide a new template argument list that contains the results of template argument deduction...
unsigned Result
A Sema::TemplateDeductionResult.
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
TemplateSpecCandidateSet(SourceLocation Loc)
diag_iterator diag_begin() const
Returns an iterator at the beginning of the sequence of suppressed diagnostics.
SourceLocation getLocation() const
TemplateDeductionInfo(SourceLocation Loc)
void NoteDeductionFailure(Sema &S)
Diagnose a template argument deduction failure.
The result type of a method or function.
SmallVector< DeducedPack *, 8 > PendingDeducedPacks
Information on packs that we're currently expanding.
#define false
Definition: stdbool.h:33
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
void addSFINAEDiagnostic(SourceLocation Loc, PartialDiagnostic PD)
Set the diagnostic which caused the SFINAE failure.
void set(Decl *Spec, DeductionFailureInfo Info)
Expr * Expression
The expression which caused a deduction failure.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
unsigned HasDiagnostic
Indicates whether a diagnostic is stored in Diagnostic.
const TemplateArgument * getFirstArg()
Return the first template argument this deduction failure refers to, if any.
Represents a template argument.
Definition: TemplateBase.h:39
llvm::PointerUnion3< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
Definition: DeclTemplate.h:38
PartialDiagnosticAt * getSFINAEDiagnostic()
Retrieve the diagnostic which caused this deduction failure, if any.
bool hasSFINAEDiagnostic() const
Is a SFINAE diagnostic available?
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set...
void * Data
Opaque pointer containing additional data about this deduction failure.
TemplateArgumentList * take()
Take ownership of the deduced template argument list.
SourceLocation getLocation() const
Returns the location at which template argument is occurring.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
TemplateArgumentList * getTemplateArgumentList()
Retrieve the template argument list associated with this deduction failure, if any.
A template argument list.
Definition: DeclTemplate.h:150
SmallVectorImpl< PartialDiagnosticAt >::const_iterator diag_iterator
Iterator over the set of suppressed diagnostics.
TemplateArgument SecondArg
The second template argument to which the template argument deduction failure refers.
void NoteCandidates(Sema &S, SourceLocation Loc)
TemplateArgument FirstArg
The first template argument to which the template argument deduction failure refers.