 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
66.7% |
14 / 21 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
95.2% |
20 / 21 |
| |
|
Line Coverage: |
98.9% |
92 / 93 |
| |
 |
|
 |
1 : //===--- Overload.h - C++ Overloading ---------------------------*- 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 data structures and types used in C++
11 : // overload resolution.
12 : //
13 : //===----------------------------------------------------------------------===//
14 :
15 : #ifndef LLVM_CLANG_SEMA_OVERLOAD_H
16 : #define LLVM_CLANG_SEMA_OVERLOAD_H
17 :
18 : #include "clang/AST/Decl.h"
19 : #include "clang/AST/Expr.h"
20 : #include "clang/AST/Type.h"
21 : #include "llvm/ADT/SmallPtrSet.h"
22 : #include "llvm/ADT/SmallVector.h"
23 :
24 : namespace clang {
25 : class ASTContext;
26 : class CXXConstructorDecl;
27 : class CXXConversionDecl;
28 : class FunctionDecl;
29 :
30 : /// OverloadingResult - Capture the result of performing overload
31 : /// resolution.
32 : enum OverloadingResult {
33 : OR_Success, ///< Overload resolution succeeded.
34 : OR_No_Viable_Function, ///< No viable function found.
35 : OR_Ambiguous, ///< Ambiguous candidates found.
36 : OR_Deleted ///< Overload resoltuion refers to a deleted function.
37 : };
38 :
39 : /// ImplicitConversionKind - The kind of implicit conversion used to
40 : /// convert an argument to a parameter's type. The enumerator values
41 : /// match with Table 9 of (C++ 13.3.3.1.1) and are listed such that
42 : /// better conversion kinds have smaller values.
43 : enum ImplicitConversionKind {
44 : ICK_Identity = 0, ///< Identity conversion (no conversion)
45 : ICK_Lvalue_To_Rvalue, ///< Lvalue-to-rvalue conversion (C++ 4.1)
46 : ICK_Array_To_Pointer, ///< Array-to-pointer conversion (C++ 4.2)
47 : ICK_Function_To_Pointer, ///< Function-to-pointer (C++ 4.3)
48 : ICK_NoReturn_Adjustment, ///< Removal of noreturn from a type (Clang)
49 : ICK_Qualification, ///< Qualification conversions (C++ 4.4)
50 : ICK_Integral_Promotion, ///< Integral promotions (C++ 4.5)
51 : ICK_Floating_Promotion, ///< Floating point promotions (C++ 4.6)
52 : ICK_Complex_Promotion, ///< Complex promotions (Clang extension)
53 : ICK_Integral_Conversion, ///< Integral conversions (C++ 4.7)
54 : ICK_Floating_Conversion, ///< Floating point conversions (C++ 4.8)
55 : ICK_Complex_Conversion, ///< Complex conversions (C99 6.3.1.6)
56 : ICK_Floating_Integral, ///< Floating-integral conversions (C++ 4.9)
57 : ICK_Complex_Real, ///< Complex-real conversions (C99 6.3.1.7)
58 : ICK_Pointer_Conversion, ///< Pointer conversions (C++ 4.10)
59 : ICK_Pointer_Member, ///< Pointer-to-member conversions (C++ 4.11)
60 : ICK_Boolean_Conversion, ///< Boolean conversions (C++ 4.12)
61 : ICK_Compatible_Conversion, ///< Conversions between compatible types in C99
62 : ICK_Derived_To_Base, ///< Derived-to-base (C++ [over.best.ics])
63 : ICK_Num_Conversion_Kinds ///< The number of conversion kinds
64 : };
65 :
66 : /// ImplicitConversionCategory - The category of an implicit
67 : /// conversion kind. The enumerator values match with Table 9 of
68 : /// (C++ 13.3.3.1.1) and are listed such that better conversion
69 : /// categories have smaller values.
70 : enum ImplicitConversionCategory {
71 : ICC_Identity = 0, ///< Identity
72 : ICC_Lvalue_Transformation, ///< Lvalue transformation
73 : ICC_Qualification_Adjustment, ///< Qualification adjustment
74 : ICC_Promotion, ///< Promotion
75 : ICC_Conversion ///< Conversion
76 : };
77 :
78 : ImplicitConversionCategory
79 : GetConversionCategory(ImplicitConversionKind Kind);
80 :
81 : /// ImplicitConversionRank - The rank of an implicit conversion
82 : /// kind. The enumerator values match with Table 9 of (C++
83 : /// 13.3.3.1.1) and are listed such that better conversion ranks
84 : /// have smaller values.
85 : enum ImplicitConversionRank {
86 : ICR_Exact_Match = 0, ///< Exact Match
87 : ICR_Promotion, ///< Promotion
88 : ICR_Conversion ///< Conversion
89 : };
90 :
91 : ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind);
92 :
93 : /// StandardConversionSequence - represents a standard conversion
94 : /// sequence (C++ 13.3.3.1.1). A standard conversion sequence
95 : /// contains between zero and three conversions. If a particular
96 : /// conversion is not needed, it will be set to the identity conversion
97 : /// (ICK_Identity). Note that the three conversions are
98 : /// specified as separate members (rather than in an array) so that
99 : /// we can keep the size of a standard conversion sequence to a
100 : /// single word.
101 : struct StandardConversionSequence {
102 : /// First -- The first conversion can be an lvalue-to-rvalue
103 : /// conversion, array-to-pointer conversion, or
104 : /// function-to-pointer conversion.
105 : ImplicitConversionKind First : 8;
106 :
107 : /// Second - The second conversion can be an integral promotion,
108 : /// floating point promotion, integral conversion, floating point
109 : /// conversion, floating-integral conversion, pointer conversion,
110 : /// pointer-to-member conversion, or boolean conversion.
111 : ImplicitConversionKind Second : 8;
112 :
113 : /// Third - The third conversion can be a qualification conversion.
114 : ImplicitConversionKind Third : 8;
115 :
116 : /// Deprecated - Whether this the deprecated conversion of a
117 : /// string literal to a pointer to non-const character data
118 : /// (C++ 4.2p2).
119 : bool Deprecated : 1;
120 :
121 : /// IncompatibleObjC - Whether this is an Objective-C conversion
122 : /// that we should warn about (if we actually use it).
123 : bool IncompatibleObjC : 1;
124 :
125 : /// ReferenceBinding - True when this is a reference binding
126 : /// (C++ [over.ics.ref]).
127 : bool ReferenceBinding : 1;
128 :
129 : /// DirectBinding - True when this is a reference binding that is a
130 : /// direct binding (C++ [dcl.init.ref]).
131 : bool DirectBinding : 1;
132 :
133 : /// RRefBinding - True when this is a reference binding of an rvalue
134 : /// reference to an rvalue (C++0x [over.ics.rank]p3b4).
135 : bool RRefBinding : 1;
136 :
137 : /// FromType - The type that this conversion is converting
138 : /// from. This is an opaque pointer that can be translated into a
139 : /// QualType.
140 : void *FromTypePtr;
141 :
142 : /// ToType - The types that this conversion is converting to in
143 : /// each step. This is an opaque pointer that can be translated
144 : /// into a QualType.
145 : void *ToTypePtrs[3];
146 :
147 : /// CopyConstructor - The copy constructor that is used to perform
148 : /// this conversion, when the conversion is actually just the
149 : /// initialization of an object via copy constructor. Such
150 : /// conversions are either identity conversions or derived-to-base
151 : /// conversions.
152 : CXXConstructorDecl *CopyConstructor;
153 :
154 68663: void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
155 107748: void setToType(unsigned Idx, QualType T) {
0: branch 0 not taken
107748: branch 1 taken
156 107748: assert(Idx < 3 && "To type index is out of range");
157 107748: ToTypePtrs[Idx] = T.getAsOpaquePtr();
158 107748: }
159 20947: void setAllToTypes(QualType T) {
160 20947: ToTypePtrs[0] = T.getAsOpaquePtr();
161 20947: ToTypePtrs[1] = ToTypePtrs[0];
162 20947: ToTypePtrs[2] = ToTypePtrs[0];
163 20947: }
164 :
165 33456: QualType getFromType() const {
166 33456: return QualType::getFromOpaquePtr(FromTypePtr);
167 : }
168 89659: QualType getToType(unsigned Idx) const {
0: branch 0 not taken
89659: branch 1 taken
169 89659: assert(Idx < 3 && "To type index is out of range");
170 89659: return QualType::getFromOpaquePtr(ToTypePtrs[Idx]);
171 : }
172 :
173 : void setAsIdentityConversion();
174 : ImplicitConversionRank getRank() const;
175 : bool isPointerConversionToBool() const;
176 : bool isPointerConversionToVoidPointer(ASTContext& Context) const;
177 : void DebugPrint() const;
178 : };
179 :
180 : /// UserDefinedConversionSequence - Represents a user-defined
181 : /// conversion sequence (C++ 13.3.3.1.2).
182 : struct UserDefinedConversionSequence {
183 : /// Before - Represents the standard conversion that occurs before
184 : /// the actual user-defined conversion. (C++ 13.3.3.1.2p1):
185 : ///
186 : /// If the user-defined conversion is specified by a constructor
187 : /// (12.3.1), the initial standard conversion sequence converts
188 : /// the source type to the type required by the argument of the
189 : /// constructor. If the user-defined conversion is specified by
190 : /// a conversion function (12.3.2), the initial standard
191 : /// conversion sequence converts the source type to the implicit
192 : /// object parameter of the conversion function.
193 : StandardConversionSequence Before;
194 :
195 : /// EllipsisConversion - When this is true, it means user-defined
196 : /// conversion sequence starts with a ... (elipsis) conversion, instead of
197 : /// a standard conversion. In this case, 'Before' field must be ignored.
198 : // FIXME. I much rather put this as the first field. But there seems to be
199 : // a gcc code gen. bug which causes a crash in a test. Putting it here seems
200 : // to work around the crash.
201 : bool EllipsisConversion : 1;
202 :
203 : /// After - Represents the standard conversion that occurs after
204 : /// the actual user-defined conversion.
205 : StandardConversionSequence After;
206 :
207 : /// ConversionFunction - The function that will perform the
208 : /// user-defined conversion.
209 : FunctionDecl* ConversionFunction;
210 :
211 : void DebugPrint() const;
212 : };
213 :
214 : /// Represents an ambiguous user-defined conversion sequence.
215 : struct AmbiguousConversionSequence {
216 : typedef llvm::SmallVector<FunctionDecl*, 4> ConversionSet;
217 :
218 : void *FromTypePtr;
219 : void *ToTypePtr;
220 : char Buffer[sizeof(ConversionSet)];
221 :
222 6: QualType getFromType() const {
223 6: return QualType::getFromOpaquePtr(FromTypePtr);
224 : }
225 10: QualType getToType() const {
226 10: return QualType::getFromOpaquePtr(ToTypePtr);
227 : }
228 25: void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
229 25: void setToType(QualType T) { ToTypePtr = T.getAsOpaquePtr(); }
230 :
231 168: ConversionSet &conversions() {
232 168: return *reinterpret_cast<ConversionSet*>(Buffer);
233 : }
234 :
235 44: const ConversionSet &conversions() const {
236 44: return *reinterpret_cast<const ConversionSet*>(Buffer);
237 : }
238 :
239 52: void addConversion(FunctionDecl *D) {
240 52: conversions().push_back(D);
241 52: }
242 :
243 : typedef ConversionSet::iterator iterator;
244 : iterator begin() { return conversions().begin(); }
245 : iterator end() { return conversions().end(); }
246 :
247 : typedef ConversionSet::const_iterator const_iterator;
248 6: const_iterator begin() const { return conversions().begin(); }
249 6: const_iterator end() const { return conversions().end(); }
250 :
251 : void construct();
252 : void destruct();
253 : void copyFrom(const AmbiguousConversionSequence &);
254 : };
255 :
256 : /// BadConversionSequence - Records information about an invalid
257 : /// conversion sequence.
258 : struct BadConversionSequence {
259 : enum FailureKind {
260 : no_conversion,
261 : unrelated_class,
262 : suppressed_user,
263 : bad_qualifiers
264 : };
265 :
266 : // This can be null, e.g. for implicit object arguments.
267 : Expr *FromExpr;
268 :
269 : FailureKind Kind;
270 :
271 : private:
272 : // The type we're converting from (an opaque QualType).
273 : void *FromTy;
274 :
275 : // The type we're converting to (an opaque QualType).
276 : void *ToTy;
277 :
278 : public:
279 57870: void init(FailureKind K, Expr *From, QualType To) {
280 57870: init(K, From->getType(), To);
281 57870: FromExpr = From;
282 57870: }
283 57926: void init(FailureKind K, QualType From, QualType To) {
284 57926: Kind = K;
285 57926: FromExpr = 0;
286 57926: setFromType(From);
287 57926: setToType(To);
288 57926: }
289 :
290 106: QualType getFromType() const { return QualType::getFromOpaquePtr(FromTy); }
291 106: QualType getToType() const { return QualType::getFromOpaquePtr(ToTy); }
292 :
293 : void setFromExpr(Expr *E) {
294 : FromExpr = E;
295 : setFromType(E->getType());
296 : }
297 57926: void setFromType(QualType T) { FromTy = T.getAsOpaquePtr(); }
298 57926: void setToType(QualType T) { ToTy = T.getAsOpaquePtr(); }
299 : };
300 :
301 : /// ImplicitConversionSequence - Represents an implicit conversion
302 : /// sequence, which may be a standard conversion sequence
303 : /// (C++ 13.3.3.1.1), user-defined conversion sequence (C++ 13.3.3.1.2),
304 : /// or an ellipsis conversion sequence (C++ 13.3.3.1.3).
305 : struct ImplicitConversionSequence {
306 : /// Kind - The kind of implicit conversion sequence. BadConversion
307 : /// specifies that there is no conversion from the source type to
308 : /// the target type. AmbiguousConversion represents the unique
309 : /// ambiguous conversion (C++0x [over.best.ics]p10).
310 : enum Kind {
311 : StandardConversion = 0,
312 : UserDefinedConversion,
313 : AmbiguousConversion,
314 : EllipsisConversion,
315 : BadConversion
316 : };
317 :
318 : private:
319 : /// ConversionKind - The kind of implicit conversion sequence.
320 : Kind ConversionKind;
321 :
322 97741: void setKind(Kind K) {
0: branch 1 not taken
97741: branch 2 taken
323 97741: if (isAmbiguous()) Ambiguous.destruct();
324 97741: ConversionKind = K;
325 97741: }
326 :
327 : public:
328 : union {
329 : /// When ConversionKind == StandardConversion, provides the
330 : /// details of the standard conversion sequence.
331 : StandardConversionSequence Standard;
332 :
333 : /// When ConversionKind == UserDefinedConversion, provides the
334 : /// details of the user-defined conversion sequence.
335 : UserDefinedConversionSequence UserDefined;
336 :
337 : /// When ConversionKind == AmbiguousConversion, provides the
338 : /// details of the ambiguous conversion.
339 : AmbiguousConversionSequence Ambiguous;
340 :
341 : /// When ConversionKind == BadConversion, provides the details
342 : /// of the bad conversion.
343 : BadConversionSequence Bad;
344 : };
345 :
346 125405: ImplicitConversionSequence() : ConversionKind(BadConversion) {}
347 323337: ~ImplicitConversionSequence() {
57: branch 1 taken
323280: branch 2 taken
348 323337: if (isAmbiguous()) Ambiguous.destruct();
349 323337: }
350 260317: ImplicitConversionSequence(const ImplicitConversionSequence &Other)
351 260317: : ConversionKind(Other.ConversionKind)
352 : {
55463: branch 1 taken
11668: branch 2 taken
32: branch 3 taken
0: branch 4 not taken
193154: branch 5 taken
0: branch 5 not taken
353 260317: switch (ConversionKind) {
354 55463: case StandardConversion: Standard = Other.Standard; break;
355 11668: case UserDefinedConversion: UserDefined = Other.UserDefined; break;
356 32: case AmbiguousConversion: Ambiguous.copyFrom(Other.Ambiguous); break;
357 0: case EllipsisConversion: break;
358 193154: case BadConversion: Bad = Other.Bad; break;
359 : }
360 260317: }
361 :
362 : ImplicitConversionSequence &
363 62385: operator=(const ImplicitConversionSequence &Other) {
1: branch 1 taken
62384: branch 2 taken
364 62385: if (isAmbiguous()) Ambiguous.destruct();
62385: branch 1 taken
0: branch 2 not taken
365 62385: new (this) ImplicitConversionSequence(Other);
366 62385: return *this;
367 : }
368 :
369 224073: Kind getKind() const { return ConversionKind; }
370 70480: bool isBad() const { return ConversionKind == BadConversion; }
371 48975: bool isStandard() const { return ConversionKind == StandardConversion; }
372 566: bool isEllipsis() const { return ConversionKind == EllipsisConversion; }
373 580676: bool isAmbiguous() const { return ConversionKind == AmbiguousConversion; }
374 28370: bool isUserDefined() const {
375 28370: return ConversionKind == UserDefinedConversion;
376 : }
377 :
378 48319: void setBad() { setKind(BadConversion); }
379 43473: void setStandard() { setKind(StandardConversion); }
380 577: void setEllipsis() { setKind(EllipsisConversion); }
381 5372: void setUserDefined() { setKind(UserDefinedConversion); }
382 26: void setAmbiguous() {
0: branch 2 not taken
383 26: if (isAmbiguous()) return;
384 26: ConversionKind = AmbiguousConversion;
385 26: Ambiguous.construct();
386 : }
387 :
388 : // The result of a comparison between implicit conversion
389 : // sequences. Use Sema::CompareImplicitConversionSequences to
390 : // actually perform the comparison.
391 : enum CompareKind {
392 : Better = -1,
393 : Indistinguishable = 0,
394 : Worse = 1
395 : };
396 :
397 : void DebugPrint() const;
398 : };
399 :
400 : enum OverloadFailureKind {
401 : ovl_fail_too_many_arguments,
402 : ovl_fail_too_few_arguments,
403 : ovl_fail_bad_conversion,
404 : ovl_fail_bad_deduction,
405 :
406 : /// This conversion candidate was not considered because it
407 : /// duplicates the work of a trivial or derived-to-base
408 : /// conversion.
409 : ovl_fail_trivial_conversion,
410 :
411 : /// This conversion candidate is not viable because its result
412 : /// type is not implicitly convertible to the desired type.
413 : ovl_fail_bad_final_conversion
414 : };
415 :
416 : /// OverloadCandidate - A single candidate in an overload set (C++ 13.3).
417 290188: struct OverloadCandidate {
418 : /// Function - The actual function that this candidate
419 : /// represents. When NULL, this is a built-in candidate
420 : /// (C++ [over.oper]) or a surrogate for a conversion to a
421 : /// function pointer or reference (C++ [over.call.object]).
422 : FunctionDecl *Function;
423 :
424 : // BuiltinTypes - Provides the return and parameter types of a
425 : // built-in overload candidate. Only valid when Function is NULL.
146106: branch 2 taken
48702: branch 3 taken
426 48702: struct {
427 : QualType ResultTy;
428 : QualType ParamTypes[3];
429 : } BuiltinTypes;
430 :
431 : /// Surrogate - The conversion function for which this candidate
432 : /// is a surrogate, but only if IsSurrogate is true.
433 : CXXConversionDecl *Surrogate;
434 :
435 : /// Conversions - The conversion sequences used to convert the
436 : /// function arguments to the function parameters.
437 : llvm::SmallVector<ImplicitConversionSequence, 4> Conversions;
438 :
439 : /// Viable - True to indicate that this overload candidate is viable.
440 : bool Viable;
441 :
442 : /// IsSurrogate - True to indicate that this candidate is a
443 : /// surrogate for a conversion to a function pointer or reference
444 : /// (C++ [over.call.object]).
445 : bool IsSurrogate;
446 :
447 : /// IgnoreObjectArgument - True to indicate that the first
448 : /// argument's conversion, which for this function represents the
449 : /// implicit object argument, should be ignored. This will be true
450 : /// when the candidate is a static member function (where the
451 : /// implicit object argument is just a placeholder) or a
452 : /// non-static member function when the call doesn't have an
453 : /// object argument.
454 : bool IgnoreObjectArgument;
455 :
456 : /// FailureKind - The reason why this candidate is not viable.
457 : /// Actually an OverloadFailureKind.
458 : unsigned char FailureKind;
459 :
460 : /// PathAccess - The 'path access' to the given function/conversion.
461 : /// Actually an AccessSpecifier.
462 : unsigned Access;
463 :
464 3417: AccessSpecifier getAccess() const {
465 3417: return AccessSpecifier(Access);
466 : }
467 :
468 : /// A structure used to record information about a failed
469 : /// template argument deduction.
470 : struct DeductionFailureInfo {
471 : // A Sema::TemplateDeductionResult.
472 : unsigned Result;
473 :
474 : // A TemplateParameter.
475 : void *TemplateParameter;
476 : };
477 :
478 : union {
479 : DeductionFailureInfo DeductionFailure;
480 :
481 : /// FinalConversion - For a conversion function (where Function is
482 : /// a CXXConversionDecl), the standard conversion that occurs
483 : /// after the call to the overload candidate to convert the result
484 : /// of calling the conversion function to the required type.
485 : StandardConversionSequence FinalConversion;
486 : };
487 :
488 : /// hasAmbiguousConversion - Returns whether this overload
489 : /// candidate requires an ambiguous conversion or not.
490 : bool hasAmbiguousConversion() const {
491 : for (llvm::SmallVectorImpl<ImplicitConversionSequence>::const_iterator
492 : I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
493 : if (I->isAmbiguous()) return true;
494 : }
495 : return false;
496 : }
497 : };
498 :
499 : /// OverloadCandidateSet - A set of overload candidates, used in C++
500 : /// overload resolution (C++ 13.3).
501 49246: class OverloadCandidateSet : public llvm::SmallVector<OverloadCandidate, 16> {
502 : typedef llvm::SmallVector<OverloadCandidate, 16> inherited;
503 : llvm::SmallPtrSet<Decl *, 16> Functions;
504 :
505 : SourceLocation Loc;
506 : public:
507 49246: OverloadCandidateSet(SourceLocation Loc) : Loc(Loc) {}
508 :
509 580: SourceLocation getLocation() const { return Loc; }
510 :
511 : /// \brief Determine when this overload candidate will be new to the
512 : /// overload set.
513 17861: bool isNewCandidate(Decl *F) {
514 17861: return Functions.insert(F->getCanonicalDecl());
515 : }
516 :
517 : /// \brief Clear out all of the candidates.
518 2047: void clear() {
519 2047: inherited::clear();
520 2047: Functions.clear();
521 2047: }
522 : };
523 : } // end namespace clang
524 :
525 : #endif // LLVM_CLANG_SEMA_OVERLOAD_H
Generated: 2010-02-10 01:31 by zcov