blob: ff59fc3a7d368682f262d685f1a5ed82769124b5 [file] [log] [blame]
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001//===--- SemaOverload.cpp - 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 provides Sema routines for C++ overloading.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
John McCall5cebab12009-11-18 07:57:50 +000015#include "Lookup.h"
Douglas Gregor0a70c4d2009-12-22 21:44:34 +000016#include "SemaInit.h"
Douglas Gregor5251f1b2008-10-21 16:13:35 +000017#include "clang/Basic/Diagnostic.h"
Douglas Gregora11693b2008-11-12 17:17:38 +000018#include "clang/Lex/Preprocessor.h"
Douglas Gregor5251f1b2008-10-21 16:13:35 +000019#include "clang/AST/ASTContext.h"
Douglas Gregor36d1b142009-10-06 17:59:45 +000020#include "clang/AST/CXXInheritance.h"
Douglas Gregor5251f1b2008-10-21 16:13:35 +000021#include "clang/AST/Expr.h"
Douglas Gregor91cea0a2008-11-19 21:05:33 +000022#include "clang/AST/ExprCXX.h"
Douglas Gregora11693b2008-11-12 17:17:38 +000023#include "clang/AST/TypeOrdering.h"
Anders Carlssond624e162009-08-26 23:45:07 +000024#include "clang/Basic/PartialDiagnostic.h"
Douglas Gregor58e008d2008-11-13 20:12:29 +000025#include "llvm/ADT/SmallPtrSet.h"
Douglas Gregor55297ac2008-12-23 00:26:44 +000026#include "llvm/ADT/STLExtras.h"
Douglas Gregor5251f1b2008-10-21 16:13:35 +000027#include <algorithm>
28
29namespace clang {
30
31/// GetConversionCategory - Retrieve the implicit conversion
32/// category corresponding to the given implicit conversion kind.
Mike Stump11289f42009-09-09 15:08:12 +000033ImplicitConversionCategory
Douglas Gregor5251f1b2008-10-21 16:13:35 +000034GetConversionCategory(ImplicitConversionKind Kind) {
35 static const ImplicitConversionCategory
36 Category[(int)ICK_Num_Conversion_Kinds] = {
37 ICC_Identity,
38 ICC_Lvalue_Transformation,
39 ICC_Lvalue_Transformation,
40 ICC_Lvalue_Transformation,
Douglas Gregor40cb9ad2009-12-09 00:47:37 +000041 ICC_Identity,
Douglas Gregor5251f1b2008-10-21 16:13:35 +000042 ICC_Qualification_Adjustment,
43 ICC_Promotion,
44 ICC_Promotion,
Douglas Gregor78ca74d2009-02-12 00:15:05 +000045 ICC_Promotion,
46 ICC_Conversion,
47 ICC_Conversion,
Douglas Gregor5251f1b2008-10-21 16:13:35 +000048 ICC_Conversion,
49 ICC_Conversion,
50 ICC_Conversion,
51 ICC_Conversion,
52 ICC_Conversion,
Douglas Gregor786ab212008-10-29 02:00:59 +000053 ICC_Conversion,
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +000054 ICC_Conversion,
Douglas Gregor5251f1b2008-10-21 16:13:35 +000055 ICC_Conversion
56 };
57 return Category[(int)Kind];
58}
59
60/// GetConversionRank - Retrieve the implicit conversion rank
61/// corresponding to the given implicit conversion kind.
62ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind) {
63 static const ImplicitConversionRank
64 Rank[(int)ICK_Num_Conversion_Kinds] = {
65 ICR_Exact_Match,
66 ICR_Exact_Match,
67 ICR_Exact_Match,
68 ICR_Exact_Match,
69 ICR_Exact_Match,
Douglas Gregor40cb9ad2009-12-09 00:47:37 +000070 ICR_Exact_Match,
Douglas Gregor5251f1b2008-10-21 16:13:35 +000071 ICR_Promotion,
72 ICR_Promotion,
Douglas Gregor78ca74d2009-02-12 00:15:05 +000073 ICR_Promotion,
74 ICR_Conversion,
75 ICR_Conversion,
Douglas Gregor5251f1b2008-10-21 16:13:35 +000076 ICR_Conversion,
77 ICR_Conversion,
78 ICR_Conversion,
79 ICR_Conversion,
80 ICR_Conversion,
Douglas Gregor786ab212008-10-29 02:00:59 +000081 ICR_Conversion,
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +000082 ICR_Conversion,
Chandler Carruth8fa1e7e2010-02-25 07:20:54 +000083 ICR_Complex_Real_Conversion
Douglas Gregor5251f1b2008-10-21 16:13:35 +000084 };
85 return Rank[(int)Kind];
86}
87
88/// GetImplicitConversionName - Return the name of this kind of
89/// implicit conversion.
90const char* GetImplicitConversionName(ImplicitConversionKind Kind) {
Nuno Lopescfca1f02009-12-23 17:49:57 +000091 static const char* const Name[(int)ICK_Num_Conversion_Kinds] = {
Douglas Gregor5251f1b2008-10-21 16:13:35 +000092 "No conversion",
93 "Lvalue-to-rvalue",
94 "Array-to-pointer",
95 "Function-to-pointer",
Douglas Gregor40cb9ad2009-12-09 00:47:37 +000096 "Noreturn adjustment",
Douglas Gregor5251f1b2008-10-21 16:13:35 +000097 "Qualification",
98 "Integral promotion",
99 "Floating point promotion",
Douglas Gregor78ca74d2009-02-12 00:15:05 +0000100 "Complex promotion",
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000101 "Integral conversion",
102 "Floating conversion",
Douglas Gregor78ca74d2009-02-12 00:15:05 +0000103 "Complex conversion",
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000104 "Floating-integral conversion",
Douglas Gregor78ca74d2009-02-12 00:15:05 +0000105 "Complex-real conversion",
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000106 "Pointer conversion",
107 "Pointer-to-member conversion",
Douglas Gregor786ab212008-10-29 02:00:59 +0000108 "Boolean conversion",
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +0000109 "Compatible-types conversion",
Douglas Gregor786ab212008-10-29 02:00:59 +0000110 "Derived-to-base conversion"
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000111 };
112 return Name[Kind];
113}
114
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000115/// StandardConversionSequence - Set the standard conversion
116/// sequence to the identity conversion.
117void StandardConversionSequence::setAsIdentityConversion() {
118 First = ICK_Identity;
119 Second = ICK_Identity;
120 Third = ICK_Identity;
Douglas Gregore489a7d2010-02-28 18:30:25 +0000121 DeprecatedStringLiteralToCharPtr = false;
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000122 ReferenceBinding = false;
123 DirectBinding = false;
Sebastian Redlf69a94a2009-03-29 22:46:24 +0000124 RRefBinding = false;
Douglas Gregor2fe98832008-11-03 19:09:14 +0000125 CopyConstructor = 0;
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000126}
127
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000128/// getRank - Retrieve the rank of this standard conversion sequence
129/// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the
130/// implicit conversions.
131ImplicitConversionRank StandardConversionSequence::getRank() const {
132 ImplicitConversionRank Rank = ICR_Exact_Match;
133 if (GetConversionRank(First) > Rank)
134 Rank = GetConversionRank(First);
135 if (GetConversionRank(Second) > Rank)
136 Rank = GetConversionRank(Second);
137 if (GetConversionRank(Third) > Rank)
138 Rank = GetConversionRank(Third);
139 return Rank;
140}
141
142/// isPointerConversionToBool - Determines whether this conversion is
143/// a conversion of a pointer or pointer-to-member to bool. This is
Mike Stump11289f42009-09-09 15:08:12 +0000144/// used as part of the ranking of standard conversion sequences
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000145/// (C++ 13.3.3.2p4).
Mike Stump11289f42009-09-09 15:08:12 +0000146bool StandardConversionSequence::isPointerConversionToBool() const {
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000147 // Note that FromType has not necessarily been transformed by the
148 // array-to-pointer or function-to-pointer implicit conversions, so
149 // check for their presence as well as checking whether FromType is
150 // a pointer.
Douglas Gregor3edc4d52010-01-27 03:51:04 +0000151 if (getToType(1)->isBooleanType() &&
John McCall0d1da222010-01-12 00:44:57 +0000152 (getFromType()->isPointerType() || getFromType()->isBlockPointerType() ||
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000153 First == ICK_Array_To_Pointer || First == ICK_Function_To_Pointer))
154 return true;
155
156 return false;
157}
158
Douglas Gregor5c407d92008-10-23 00:40:37 +0000159/// isPointerConversionToVoidPointer - Determines whether this
160/// conversion is a conversion of a pointer to a void pointer. This is
161/// used as part of the ranking of standard conversion sequences (C++
162/// 13.3.3.2p4).
Mike Stump11289f42009-09-09 15:08:12 +0000163bool
Douglas Gregor5c407d92008-10-23 00:40:37 +0000164StandardConversionSequence::
Mike Stump11289f42009-09-09 15:08:12 +0000165isPointerConversionToVoidPointer(ASTContext& Context) const {
John McCall0d1da222010-01-12 00:44:57 +0000166 QualType FromType = getFromType();
Douglas Gregor3edc4d52010-01-27 03:51:04 +0000167 QualType ToType = getToType(1);
Douglas Gregor5c407d92008-10-23 00:40:37 +0000168
169 // Note that FromType has not necessarily been transformed by the
170 // array-to-pointer implicit conversion, so check for its presence
171 // and redo the conversion to get a pointer.
172 if (First == ICK_Array_To_Pointer)
173 FromType = Context.getArrayDecayedType(FromType);
174
Douglas Gregor1aa450a2009-12-13 21:37:05 +0000175 if (Second == ICK_Pointer_Conversion && FromType->isPointerType())
Ted Kremenekc23c7e62009-07-29 21:53:49 +0000176 if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
Douglas Gregor5c407d92008-10-23 00:40:37 +0000177 return ToPtrType->getPointeeType()->isVoidType();
178
179 return false;
180}
181
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000182/// DebugPrint - Print this standard conversion sequence to standard
183/// error. Useful for debugging overloading issues.
184void StandardConversionSequence::DebugPrint() const {
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000185 llvm::raw_ostream &OS = llvm::errs();
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000186 bool PrintedSomething = false;
187 if (First != ICK_Identity) {
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000188 OS << GetImplicitConversionName(First);
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000189 PrintedSomething = true;
190 }
191
192 if (Second != ICK_Identity) {
193 if (PrintedSomething) {
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000194 OS << " -> ";
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000195 }
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000196 OS << GetImplicitConversionName(Second);
Douglas Gregor2fe98832008-11-03 19:09:14 +0000197
198 if (CopyConstructor) {
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000199 OS << " (by copy constructor)";
Douglas Gregor2fe98832008-11-03 19:09:14 +0000200 } else if (DirectBinding) {
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000201 OS << " (direct reference binding)";
Douglas Gregor2fe98832008-11-03 19:09:14 +0000202 } else if (ReferenceBinding) {
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000203 OS << " (reference binding)";
Douglas Gregor2fe98832008-11-03 19:09:14 +0000204 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000205 PrintedSomething = true;
206 }
207
208 if (Third != ICK_Identity) {
209 if (PrintedSomething) {
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000210 OS << " -> ";
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000211 }
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000212 OS << GetImplicitConversionName(Third);
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000213 PrintedSomething = true;
214 }
215
216 if (!PrintedSomething) {
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000217 OS << "No conversions required";
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000218 }
219}
220
221/// DebugPrint - Print this user-defined conversion sequence to standard
222/// error. Useful for debugging overloading issues.
223void UserDefinedConversionSequence::DebugPrint() const {
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000224 llvm::raw_ostream &OS = llvm::errs();
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000225 if (Before.First || Before.Second || Before.Third) {
226 Before.DebugPrint();
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000227 OS << " -> ";
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000228 }
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000229 OS << "'" << ConversionFunction->getNameAsString() << "'";
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000230 if (After.First || After.Second || After.Third) {
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000231 OS << " -> ";
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000232 After.DebugPrint();
233 }
234}
235
236/// DebugPrint - Print this implicit conversion sequence to standard
237/// error. Useful for debugging overloading issues.
238void ImplicitConversionSequence::DebugPrint() const {
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000239 llvm::raw_ostream &OS = llvm::errs();
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000240 switch (ConversionKind) {
241 case StandardConversion:
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000242 OS << "Standard conversion: ";
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000243 Standard.DebugPrint();
244 break;
245 case UserDefinedConversion:
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000246 OS << "User-defined conversion: ";
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000247 UserDefined.DebugPrint();
248 break;
249 case EllipsisConversion:
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000250 OS << "Ellipsis conversion";
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000251 break;
John McCall0d1da222010-01-12 00:44:57 +0000252 case AmbiguousConversion:
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000253 OS << "Ambiguous conversion";
John McCall0d1da222010-01-12 00:44:57 +0000254 break;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000255 case BadConversion:
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000256 OS << "Bad conversion";
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000257 break;
258 }
259
Daniel Dunbar42e3df02010-01-22 02:04:41 +0000260 OS << "\n";
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000261}
262
John McCall0d1da222010-01-12 00:44:57 +0000263void AmbiguousConversionSequence::construct() {
264 new (&conversions()) ConversionSet();
265}
266
267void AmbiguousConversionSequence::destruct() {
268 conversions().~ConversionSet();
269}
270
271void
272AmbiguousConversionSequence::copyFrom(const AmbiguousConversionSequence &O) {
273 FromTypePtr = O.FromTypePtr;
274 ToTypePtr = O.ToTypePtr;
275 new (&conversions()) ConversionSet(O.conversions());
276}
277
278
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000279// IsOverload - Determine whether the given New declaration is an
John McCall3d988d92009-12-02 08:47:38 +0000280// overload of the declarations in Old. This routine returns false if
281// New and Old cannot be overloaded, e.g., if New has the same
282// signature as some function in Old (C++ 1.3.10) or if the Old
283// declarations aren't functions (or function templates) at all. When
John McCalldaa3d6b2009-12-09 03:35:25 +0000284// it does return false, MatchedDecl will point to the decl that New
285// cannot be overloaded with. This decl may be a UsingShadowDecl on
286// top of the underlying declaration.
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000287//
288// Example: Given the following input:
289//
290// void f(int, float); // #1
291// void f(int, int); // #2
292// int f(int, int); // #3
293//
294// When we process #1, there is no previous declaration of "f",
Mike Stump11289f42009-09-09 15:08:12 +0000295// so IsOverload will not be used.
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000296//
John McCall3d988d92009-12-02 08:47:38 +0000297// When we process #2, Old contains only the FunctionDecl for #1. By
298// comparing the parameter types, we see that #1 and #2 are overloaded
299// (since they have different signatures), so this routine returns
300// false; MatchedDecl is unchanged.
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000301//
John McCall3d988d92009-12-02 08:47:38 +0000302// When we process #3, Old is an overload set containing #1 and #2. We
303// compare the signatures of #3 to #1 (they're overloaded, so we do
304// nothing) and then #3 to #2. Since the signatures of #3 and #2 are
305// identical (return types of functions are not part of the
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000306// signature), IsOverload returns false and MatchedDecl will be set to
307// point to the FunctionDecl for #2.
John McCalldaa3d6b2009-12-09 03:35:25 +0000308Sema::OverloadKind
John McCall84d87672009-12-10 09:41:52 +0000309Sema::CheckOverload(FunctionDecl *New, const LookupResult &Old,
310 NamedDecl *&Match) {
John McCall3d988d92009-12-02 08:47:38 +0000311 for (LookupResult::iterator I = Old.begin(), E = Old.end();
John McCall1f82f242009-11-18 22:49:29 +0000312 I != E; ++I) {
John McCall3d988d92009-12-02 08:47:38 +0000313 NamedDecl *OldD = (*I)->getUnderlyingDecl();
314 if (FunctionTemplateDecl *OldT = dyn_cast<FunctionTemplateDecl>(OldD)) {
John McCall1f82f242009-11-18 22:49:29 +0000315 if (!IsOverload(New, OldT->getTemplatedDecl())) {
John McCalldaa3d6b2009-12-09 03:35:25 +0000316 Match = *I;
317 return Ovl_Match;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000318 }
John McCall3d988d92009-12-02 08:47:38 +0000319 } else if (FunctionDecl *OldF = dyn_cast<FunctionDecl>(OldD)) {
John McCall1f82f242009-11-18 22:49:29 +0000320 if (!IsOverload(New, OldF)) {
John McCalldaa3d6b2009-12-09 03:35:25 +0000321 Match = *I;
322 return Ovl_Match;
John McCall1f82f242009-11-18 22:49:29 +0000323 }
John McCall84d87672009-12-10 09:41:52 +0000324 } else if (isa<UsingDecl>(OldD) || isa<TagDecl>(OldD)) {
325 // We can overload with these, which can show up when doing
326 // redeclaration checks for UsingDecls.
327 assert(Old.getLookupKind() == LookupUsingDeclName);
328 } else if (isa<UnresolvedUsingValueDecl>(OldD)) {
329 // Optimistically assume that an unresolved using decl will
330 // overload; if it doesn't, we'll have to diagnose during
331 // template instantiation.
332 } else {
John McCall1f82f242009-11-18 22:49:29 +0000333 // (C++ 13p1):
334 // Only function declarations can be overloaded; object and type
335 // declarations cannot be overloaded.
John McCalldaa3d6b2009-12-09 03:35:25 +0000336 Match = *I;
337 return Ovl_NonFunction;
John McCall1f82f242009-11-18 22:49:29 +0000338 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000339 }
John McCall1f82f242009-11-18 22:49:29 +0000340
John McCalldaa3d6b2009-12-09 03:35:25 +0000341 return Ovl_Overload;
John McCall1f82f242009-11-18 22:49:29 +0000342}
343
344bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old) {
345 FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
346 FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
347
348 // C++ [temp.fct]p2:
349 // A function template can be overloaded with other function templates
350 // and with normal (non-template) functions.
351 if ((OldTemplate == 0) != (NewTemplate == 0))
352 return true;
353
354 // Is the function New an overload of the function Old?
355 QualType OldQType = Context.getCanonicalType(Old->getType());
356 QualType NewQType = Context.getCanonicalType(New->getType());
357
358 // Compare the signatures (C++ 1.3.10) of the two functions to
359 // determine whether they are overloads. If we find any mismatch
360 // in the signature, they are overloads.
361
362 // If either of these functions is a K&R-style function (no
363 // prototype), then we consider them to have matching signatures.
364 if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
365 isa<FunctionNoProtoType>(NewQType.getTypePtr()))
366 return false;
367
368 FunctionProtoType* OldType = cast<FunctionProtoType>(OldQType);
369 FunctionProtoType* NewType = cast<FunctionProtoType>(NewQType);
370
371 // The signature of a function includes the types of its
372 // parameters (C++ 1.3.10), which includes the presence or absence
373 // of the ellipsis; see C++ DR 357).
374 if (OldQType != NewQType &&
375 (OldType->getNumArgs() != NewType->getNumArgs() ||
376 OldType->isVariadic() != NewType->isVariadic() ||
377 !std::equal(OldType->arg_type_begin(), OldType->arg_type_end(),
378 NewType->arg_type_begin())))
379 return true;
380
381 // C++ [temp.over.link]p4:
382 // The signature of a function template consists of its function
383 // signature, its return type and its template parameter list. The names
384 // of the template parameters are significant only for establishing the
385 // relationship between the template parameters and the rest of the
386 // signature.
387 //
388 // We check the return type and template parameter lists for function
389 // templates first; the remaining checks follow.
390 if (NewTemplate &&
391 (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
392 OldTemplate->getTemplateParameters(),
393 false, TPL_TemplateMatch) ||
394 OldType->getResultType() != NewType->getResultType()))
395 return true;
396
397 // If the function is a class member, its signature includes the
398 // cv-qualifiers (if any) on the function itself.
399 //
400 // As part of this, also check whether one of the member functions
401 // is static, in which case they are not overloads (C++
402 // 13.1p2). While not part of the definition of the signature,
403 // this check is important to determine whether these functions
404 // can be overloaded.
405 CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
406 CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
407 if (OldMethod && NewMethod &&
408 !OldMethod->isStatic() && !NewMethod->isStatic() &&
409 OldMethod->getTypeQualifiers() != NewMethod->getTypeQualifiers())
410 return true;
411
412 // The signatures match; this is not an overload.
413 return false;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000414}
415
Douglas Gregor8e1cf602008-10-29 00:13:59 +0000416/// TryImplicitConversion - Attempt to perform an implicit conversion
417/// from the given expression (Expr) to the given type (ToType). This
418/// function returns an implicit conversion sequence that can be used
419/// to perform the initialization. Given
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000420///
421/// void f(float f);
422/// void g(int i) { f(i); }
423///
424/// this routine would produce an implicit conversion sequence to
425/// describe the initialization of f from i, which will be a standard
426/// conversion sequence containing an lvalue-to-rvalue conversion (C++
427/// 4.1) followed by a floating-integral conversion (C++ 4.9).
428//
429/// Note that this routine only determines how the conversion can be
430/// performed; it does not actually perform the conversion. As such,
431/// it will not produce any diagnostics if no conversion is available,
432/// but will instead return an implicit conversion sequence of kind
433/// "BadConversion".
Douglas Gregor2fe98832008-11-03 19:09:14 +0000434///
435/// If @p SuppressUserConversions, then user-defined conversions are
436/// not permitted.
Douglas Gregor5fb53972009-01-14 15:45:31 +0000437/// If @p AllowExplicit, then explicit user-defined conversions are
438/// permitted.
Sebastian Redl42e92c42009-04-12 17:16:29 +0000439/// If @p ForceRValue, then overloading is performed as if From was an rvalue,
440/// no matter its actual lvalueness.
Fariborz Jahanianb3c44f92009-10-01 20:39:51 +0000441/// If @p UserCast, the implicit conversion is being done for a user-specified
442/// cast.
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000443ImplicitConversionSequence
Anders Carlsson5ec4abf2009-08-27 17:14:02 +0000444Sema::TryImplicitConversion(Expr* From, QualType ToType,
445 bool SuppressUserConversions,
Anders Carlsson228eea32009-08-28 15:33:32 +0000446 bool AllowExplicit, bool ForceRValue,
Fariborz Jahanianb3c44f92009-10-01 20:39:51 +0000447 bool InOverloadResolution,
448 bool UserCast) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000449 ImplicitConversionSequence ICS;
John McCallbc077cf2010-02-08 23:07:23 +0000450 if (IsStandardConversion(From, ToType, InOverloadResolution, ICS.Standard)) {
John McCall0d1da222010-01-12 00:44:57 +0000451 ICS.setStandard();
John McCallbc077cf2010-02-08 23:07:23 +0000452 return ICS;
453 }
454
455 if (!getLangOptions().CPlusPlus) {
John McCall65eb8792010-02-25 01:37:24 +0000456 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
John McCallbc077cf2010-02-08 23:07:23 +0000457 return ICS;
458 }
459
460 OverloadCandidateSet Conversions(From->getExprLoc());
461 OverloadingResult UserDefResult
462 = IsUserDefinedConversion(From, ToType, ICS.UserDefined, Conversions,
463 !SuppressUserConversions, AllowExplicit,
464 ForceRValue, UserCast);
465
466 if (UserDefResult == OR_Success) {
John McCall0d1da222010-01-12 00:44:57 +0000467 ICS.setUserDefined();
Douglas Gregor05379422008-11-03 17:51:48 +0000468 // C++ [over.ics.user]p4:
469 // A conversion of an expression of class type to the same class
470 // type is given Exact Match rank, and a conversion of an
471 // expression of class type to a base class of that type is
472 // given Conversion rank, in spite of the fact that a copy
473 // constructor (i.e., a user-defined conversion function) is
474 // called for those cases.
Mike Stump11289f42009-09-09 15:08:12 +0000475 if (CXXConstructorDecl *Constructor
Douglas Gregor05379422008-11-03 17:51:48 +0000476 = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
Mike Stump11289f42009-09-09 15:08:12 +0000477 QualType FromCanon
Douglas Gregorbb2e68832009-02-02 22:11:10 +0000478 = Context.getCanonicalType(From->getType().getUnqualifiedType());
479 QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
Douglas Gregor507eb872009-12-22 00:34:07 +0000480 if (Constructor->isCopyConstructor() &&
Douglas Gregor4141d5b2009-12-22 00:21:20 +0000481 (FromCanon == ToCanon || IsDerivedFrom(FromCanon, ToCanon))) {
Douglas Gregor2fe98832008-11-03 19:09:14 +0000482 // Turn this into a "standard" conversion sequence, so that it
483 // gets ranked with standard conversion sequences.
John McCall0d1da222010-01-12 00:44:57 +0000484 ICS.setStandard();
Douglas Gregor05379422008-11-03 17:51:48 +0000485 ICS.Standard.setAsIdentityConversion();
John McCall0d1da222010-01-12 00:44:57 +0000486 ICS.Standard.setFromType(From->getType());
Douglas Gregor3edc4d52010-01-27 03:51:04 +0000487 ICS.Standard.setAllToTypes(ToType);
Douglas Gregor2fe98832008-11-03 19:09:14 +0000488 ICS.Standard.CopyConstructor = Constructor;
Douglas Gregorbb2e68832009-02-02 22:11:10 +0000489 if (ToCanon != FromCanon)
Douglas Gregor05379422008-11-03 17:51:48 +0000490 ICS.Standard.Second = ICK_Derived_To_Base;
491 }
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000492 }
Douglas Gregor576e98c2009-01-30 23:27:23 +0000493
494 // C++ [over.best.ics]p4:
495 // However, when considering the argument of a user-defined
496 // conversion function that is a candidate by 13.3.1.3 when
497 // invoked for the copying of the temporary in the second step
498 // of a class copy-initialization, or by 13.3.1.4, 13.3.1.5, or
499 // 13.3.1.6 in all cases, only standard conversion sequences and
500 // ellipsis conversion sequences are allowed.
John McCall6a61b522010-01-13 09:16:55 +0000501 if (SuppressUserConversions && ICS.isUserDefined()) {
John McCall65eb8792010-02-25 01:37:24 +0000502 ICS.setBad(BadConversionSequence::suppressed_user, From, ToType);
John McCall6a61b522010-01-13 09:16:55 +0000503 }
John McCalle8c8cd22010-01-13 22:30:33 +0000504 } else if (UserDefResult == OR_Ambiguous && !SuppressUserConversions) {
John McCall0d1da222010-01-12 00:44:57 +0000505 ICS.setAmbiguous();
506 ICS.Ambiguous.setFromType(From->getType());
507 ICS.Ambiguous.setToType(ToType);
508 for (OverloadCandidateSet::iterator Cand = Conversions.begin();
509 Cand != Conversions.end(); ++Cand)
510 if (Cand->Viable)
511 ICS.Ambiguous.addConversion(Cand->Function);
Fariborz Jahanian21ccf062009-09-23 00:58:07 +0000512 } else {
John McCall65eb8792010-02-25 01:37:24 +0000513 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
Fariborz Jahanian21ccf062009-09-23 00:58:07 +0000514 }
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000515
516 return ICS;
517}
518
Douglas Gregor40cb9ad2009-12-09 00:47:37 +0000519/// \brief Determine whether the conversion from FromType to ToType is a valid
520/// conversion that strips "noreturn" off the nested function type.
521static bool IsNoReturnConversion(ASTContext &Context, QualType FromType,
522 QualType ToType, QualType &ResultTy) {
523 if (Context.hasSameUnqualifiedType(FromType, ToType))
524 return false;
525
526 // Strip the noreturn off the type we're converting from; noreturn can
527 // safely be removed.
528 FromType = Context.getNoReturnType(FromType, false);
529 if (!Context.hasSameUnqualifiedType(FromType, ToType))
530 return false;
531
532 ResultTy = FromType;
533 return true;
534}
535
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000536/// IsStandardConversion - Determines whether there is a standard
537/// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
538/// expression From to the type ToType. Standard conversion sequences
539/// only consider non-class types; for conversions that involve class
540/// types, use TryImplicitConversion. If a conversion exists, SCS will
541/// contain the standard conversion sequence required to perform this
542/// conversion and this routine will return true. Otherwise, this
543/// routine will return false and the value of SCS is unspecified.
Mike Stump11289f42009-09-09 15:08:12 +0000544bool
545Sema::IsStandardConversion(Expr* From, QualType ToType,
Anders Carlsson228eea32009-08-28 15:33:32 +0000546 bool InOverloadResolution,
Mike Stump11289f42009-09-09 15:08:12 +0000547 StandardConversionSequence &SCS) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000548 QualType FromType = From->getType();
549
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000550 // Standard conversions (C++ [conv])
Douglas Gregora11693b2008-11-12 17:17:38 +0000551 SCS.setAsIdentityConversion();
Douglas Gregore489a7d2010-02-28 18:30:25 +0000552 SCS.DeprecatedStringLiteralToCharPtr = false;
Douglas Gregor47d3f272008-12-19 17:40:08 +0000553 SCS.IncompatibleObjC = false;
John McCall0d1da222010-01-12 00:44:57 +0000554 SCS.setFromType(FromType);
Douglas Gregor2fe98832008-11-03 19:09:14 +0000555 SCS.CopyConstructor = 0;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000556
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +0000557 // There are no standard conversions for class types in C++, so
Mike Stump11289f42009-09-09 15:08:12 +0000558 // abort early. When overloading in C, however, we do permit
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +0000559 if (FromType->isRecordType() || ToType->isRecordType()) {
560 if (getLangOptions().CPlusPlus)
561 return false;
562
Mike Stump11289f42009-09-09 15:08:12 +0000563 // When we're overloading in C, we allow, as standard conversions,
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +0000564 }
565
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000566 // The first conversion can be an lvalue-to-rvalue conversion,
567 // array-to-pointer conversion, or function-to-pointer conversion
568 // (C++ 4p1).
569
Mike Stump11289f42009-09-09 15:08:12 +0000570 // Lvalue-to-rvalue conversion (C++ 4.1):
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000571 // An lvalue (3.10) of a non-function, non-array type T can be
572 // converted to an rvalue.
573 Expr::isLvalueResult argIsLvalue = From->isLvalue(Context);
Mike Stump11289f42009-09-09 15:08:12 +0000574 if (argIsLvalue == Expr::LV_Valid &&
Douglas Gregorcd695e52008-11-10 20:40:00 +0000575 !FromType->isFunctionType() && !FromType->isArrayType() &&
Douglas Gregor1baf54e2009-03-13 18:40:31 +0000576 Context.getCanonicalType(FromType) != Context.OverloadTy) {
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000577 SCS.First = ICK_Lvalue_To_Rvalue;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000578
579 // If T is a non-class type, the type of the rvalue is the
580 // cv-unqualified version of T. Otherwise, the type of the rvalue
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +0000581 // is T (C++ 4.1p1). C++ can't get here with class types; in C, we
582 // just strip the qualifiers because they don't matter.
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000583 FromType = FromType.getUnqualifiedType();
Mike Stump12b8ce12009-08-04 21:02:39 +0000584 } else if (FromType->isArrayType()) {
585 // Array-to-pointer conversion (C++ 4.2)
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000586 SCS.First = ICK_Array_To_Pointer;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000587
588 // An lvalue or rvalue of type "array of N T" or "array of unknown
589 // bound of T" can be converted to an rvalue of type "pointer to
590 // T" (C++ 4.2p1).
591 FromType = Context.getArrayDecayedType(FromType);
592
593 if (IsStringLiteralToNonConstPointerConversion(From, ToType)) {
594 // This conversion is deprecated. (C++ D.4).
Douglas Gregore489a7d2010-02-28 18:30:25 +0000595 SCS.DeprecatedStringLiteralToCharPtr = true;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000596
597 // For the purpose of ranking in overload resolution
598 // (13.3.3.1.1), this conversion is considered an
599 // array-to-pointer conversion followed by a qualification
600 // conversion (4.4). (C++ 4.2p2)
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000601 SCS.Second = ICK_Identity;
602 SCS.Third = ICK_Qualification;
Douglas Gregor3edc4d52010-01-27 03:51:04 +0000603 SCS.setAllToTypes(FromType);
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000604 return true;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000605 }
Mike Stump12b8ce12009-08-04 21:02:39 +0000606 } else if (FromType->isFunctionType() && argIsLvalue == Expr::LV_Valid) {
607 // Function-to-pointer conversion (C++ 4.3).
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000608 SCS.First = ICK_Function_To_Pointer;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000609
610 // An lvalue of function type T can be converted to an rvalue of
611 // type "pointer to T." The result is a pointer to the
612 // function. (C++ 4.3p1).
613 FromType = Context.getPointerType(FromType);
Mike Stump11289f42009-09-09 15:08:12 +0000614 } else if (FunctionDecl *Fn
Douglas Gregor40cb9ad2009-12-09 00:47:37 +0000615 = ResolveAddressOfOverloadedFunction(From, ToType, false)) {
Mike Stump12b8ce12009-08-04 21:02:39 +0000616 // Address of overloaded function (C++ [over.over]).
Douglas Gregorcd695e52008-11-10 20:40:00 +0000617 SCS.First = ICK_Function_To_Pointer;
618
619 // We were able to resolve the address of the overloaded function,
620 // so we can convert to the type of that function.
621 FromType = Fn->getType();
Sebastian Redl0f8b23f2009-03-16 23:22:08 +0000622 if (ToType->isLValueReferenceType())
623 FromType = Context.getLValueReferenceType(FromType);
624 else if (ToType->isRValueReferenceType())
625 FromType = Context.getRValueReferenceType(FromType);
Sebastian Redl18f8ff62009-02-04 21:23:32 +0000626 else if (ToType->isMemberPointerType()) {
627 // Resolve address only succeeds if both sides are member pointers,
628 // but it doesn't have to be the same class. See DR 247.
629 // Note that this means that the type of &Derived::fn can be
630 // Ret (Base::*)(Args) if the fn overload actually found is from the
631 // base class, even if it was brought into the derived class via a
632 // using declaration. The standard isn't clear on this issue at all.
633 CXXMethodDecl *M = cast<CXXMethodDecl>(Fn);
634 FromType = Context.getMemberPointerType(FromType,
635 Context.getTypeDeclType(M->getParent()).getTypePtr());
636 } else
Douglas Gregorcd695e52008-11-10 20:40:00 +0000637 FromType = Context.getPointerType(FromType);
Mike Stump12b8ce12009-08-04 21:02:39 +0000638 } else {
639 // We don't require any conversions for the first step.
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000640 SCS.First = ICK_Identity;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000641 }
Douglas Gregor3edc4d52010-01-27 03:51:04 +0000642 SCS.setToType(0, FromType);
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000643
644 // The second conversion can be an integral promotion, floating
645 // point promotion, integral conversion, floating point conversion,
646 // floating-integral conversion, pointer conversion,
647 // pointer-to-member conversion, or boolean conversion (C++ 4p1).
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +0000648 // For overloading in C, this can also be a "compatible-type"
649 // conversion.
Douglas Gregor47d3f272008-12-19 17:40:08 +0000650 bool IncompatibleObjC = false;
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +0000651 if (Context.hasSameUnqualifiedType(FromType, ToType)) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000652 // The unqualified versions of the types are the same: there's no
653 // conversion to do.
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000654 SCS.Second = ICK_Identity;
Mike Stump12b8ce12009-08-04 21:02:39 +0000655 } else if (IsIntegralPromotion(From, FromType, ToType)) {
Mike Stump11289f42009-09-09 15:08:12 +0000656 // Integral promotion (C++ 4.5).
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000657 SCS.Second = ICK_Integral_Promotion;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000658 FromType = ToType.getUnqualifiedType();
Mike Stump12b8ce12009-08-04 21:02:39 +0000659 } else if (IsFloatingPointPromotion(FromType, ToType)) {
660 // Floating point promotion (C++ 4.6).
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000661 SCS.Second = ICK_Floating_Promotion;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000662 FromType = ToType.getUnqualifiedType();
Mike Stump12b8ce12009-08-04 21:02:39 +0000663 } else if (IsComplexPromotion(FromType, ToType)) {
664 // Complex promotion (Clang extension)
Douglas Gregor78ca74d2009-02-12 00:15:05 +0000665 SCS.Second = ICK_Complex_Promotion;
666 FromType = ToType.getUnqualifiedType();
Mike Stump12b8ce12009-08-04 21:02:39 +0000667 } else if ((FromType->isIntegralType() || FromType->isEnumeralType()) &&
Sebastian Redl72b8aef2008-10-31 14:43:28 +0000668 (ToType->isIntegralType() && !ToType->isEnumeralType())) {
Mike Stump12b8ce12009-08-04 21:02:39 +0000669 // Integral conversions (C++ 4.7).
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000670 SCS.Second = ICK_Integral_Conversion;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000671 FromType = ToType.getUnqualifiedType();
Mike Stump12b8ce12009-08-04 21:02:39 +0000672 } else if (FromType->isComplexType() && ToType->isComplexType()) {
673 // Complex conversions (C99 6.3.1.6)
Douglas Gregor78ca74d2009-02-12 00:15:05 +0000674 SCS.Second = ICK_Complex_Conversion;
675 FromType = ToType.getUnqualifiedType();
Chandler Carruth8fa1e7e2010-02-25 07:20:54 +0000676 } else if ((FromType->isComplexType() && ToType->isArithmeticType()) ||
677 (ToType->isComplexType() && FromType->isArithmeticType())) {
678 // Complex-real conversions (C99 6.3.1.7)
679 SCS.Second = ICK_Complex_Real;
680 FromType = ToType.getUnqualifiedType();
681 } else if (FromType->isFloatingType() && ToType->isFloatingType()) {
682 // Floating point conversions (C++ 4.8).
683 SCS.Second = ICK_Floating_Conversion;
684 FromType = ToType.getUnqualifiedType();
Mike Stump12b8ce12009-08-04 21:02:39 +0000685 } else if ((FromType->isFloatingType() &&
686 ToType->isIntegralType() && (!ToType->isBooleanType() &&
687 !ToType->isEnumeralType())) ||
Mike Stump11289f42009-09-09 15:08:12 +0000688 ((FromType->isIntegralType() || FromType->isEnumeralType()) &&
Mike Stump12b8ce12009-08-04 21:02:39 +0000689 ToType->isFloatingType())) {
690 // Floating-integral conversions (C++ 4.9).
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000691 SCS.Second = ICK_Floating_Integral;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000692 FromType = ToType.getUnqualifiedType();
Anders Carlsson228eea32009-08-28 15:33:32 +0000693 } else if (IsPointerConversion(From, FromType, ToType, InOverloadResolution,
694 FromType, IncompatibleObjC)) {
Mike Stump12b8ce12009-08-04 21:02:39 +0000695 // Pointer conversions (C++ 4.10).
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000696 SCS.Second = ICK_Pointer_Conversion;
Douglas Gregor47d3f272008-12-19 17:40:08 +0000697 SCS.IncompatibleObjC = IncompatibleObjC;
Douglas Gregor56751b52009-09-25 04:25:58 +0000698 } else if (IsMemberPointerConversion(From, FromType, ToType,
699 InOverloadResolution, FromType)) {
Mike Stump12b8ce12009-08-04 21:02:39 +0000700 // Pointer to member conversions (4.11).
Sebastian Redl72b597d2009-01-25 19:43:20 +0000701 SCS.Second = ICK_Pointer_Member;
Mike Stump12b8ce12009-08-04 21:02:39 +0000702 } else if (ToType->isBooleanType() &&
703 (FromType->isArithmeticType() ||
704 FromType->isEnumeralType() ||
Fariborz Jahanian88118852009-12-11 21:23:13 +0000705 FromType->isAnyPointerType() ||
Mike Stump12b8ce12009-08-04 21:02:39 +0000706 FromType->isBlockPointerType() ||
707 FromType->isMemberPointerType() ||
708 FromType->isNullPtrType())) {
709 // Boolean conversions (C++ 4.12).
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000710 SCS.Second = ICK_Boolean_Conversion;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000711 FromType = Context.BoolTy;
Mike Stump11289f42009-09-09 15:08:12 +0000712 } else if (!getLangOptions().CPlusPlus &&
Mike Stump12b8ce12009-08-04 21:02:39 +0000713 Context.typesAreCompatible(ToType, FromType)) {
714 // Compatible conversions (Clang extension for C function overloading)
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +0000715 SCS.Second = ICK_Compatible_Conversion;
Douglas Gregor40cb9ad2009-12-09 00:47:37 +0000716 } else if (IsNoReturnConversion(Context, FromType, ToType, FromType)) {
717 // Treat a conversion that strips "noreturn" as an identity conversion.
718 SCS.Second = ICK_NoReturn_Adjustment;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000719 } else {
720 // No second conversion required.
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000721 SCS.Second = ICK_Identity;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000722 }
Douglas Gregor3edc4d52010-01-27 03:51:04 +0000723 SCS.setToType(1, FromType);
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000724
Douglas Gregor8e1cf602008-10-29 00:13:59 +0000725 QualType CanonFrom;
726 QualType CanonTo;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000727 // The third conversion can be a qualification conversion (C++ 4p1).
Douglas Gregor9a657932008-10-21 23:43:52 +0000728 if (IsQualificationConversion(FromType, ToType)) {
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000729 SCS.Third = ICK_Qualification;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000730 FromType = ToType;
Douglas Gregor8e1cf602008-10-29 00:13:59 +0000731 CanonFrom = Context.getCanonicalType(FromType);
732 CanonTo = Context.getCanonicalType(ToType);
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000733 } else {
734 // No conversion required
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000735 SCS.Third = ICK_Identity;
736
Mike Stump11289f42009-09-09 15:08:12 +0000737 // C++ [over.best.ics]p6:
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000738 // [...] Any difference in top-level cv-qualification is
739 // subsumed by the initialization itself and does not constitute
740 // a conversion. [...]
Douglas Gregor8e1cf602008-10-29 00:13:59 +0000741 CanonFrom = Context.getCanonicalType(FromType);
Mike Stump11289f42009-09-09 15:08:12 +0000742 CanonTo = Context.getCanonicalType(ToType);
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +0000743 if (CanonFrom.getLocalUnqualifiedType()
744 == CanonTo.getLocalUnqualifiedType() &&
745 CanonFrom.getLocalCVRQualifiers() != CanonTo.getLocalCVRQualifiers()) {
Douglas Gregor8e1cf602008-10-29 00:13:59 +0000746 FromType = ToType;
747 CanonFrom = CanonTo;
748 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000749 }
Douglas Gregor3edc4d52010-01-27 03:51:04 +0000750 SCS.setToType(2, FromType);
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000751
752 // If we have not converted the argument type to the parameter type,
753 // this is a bad conversion sequence.
Douglas Gregor8e1cf602008-10-29 00:13:59 +0000754 if (CanonFrom != CanonTo)
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000755 return false;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000756
Douglas Gregor26bee0b2008-10-31 16:23:19 +0000757 return true;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000758}
759
760/// IsIntegralPromotion - Determines whether the conversion from the
761/// expression From (whose potentially-adjusted type is FromType) to
762/// ToType is an integral promotion (C++ 4.5). If so, returns true and
763/// sets PromotedType to the promoted type.
Mike Stump11289f42009-09-09 15:08:12 +0000764bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
John McCall9dd450b2009-09-21 23:43:11 +0000765 const BuiltinType *To = ToType->getAs<BuiltinType>();
Sebastian Redlee547972008-11-04 15:59:10 +0000766 // All integers are built-in.
Sebastian Redl72b8aef2008-10-31 14:43:28 +0000767 if (!To) {
768 return false;
769 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000770
771 // An rvalue of type char, signed char, unsigned char, short int, or
772 // unsigned short int can be converted to an rvalue of type int if
773 // int can represent all the values of the source type; otherwise,
774 // the source rvalue can be converted to an rvalue of type unsigned
775 // int (C++ 4.5p1).
Douglas Gregora71cc152010-02-02 20:10:50 +0000776 if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() &&
777 !FromType->isEnumeralType()) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000778 if (// We can promote any signed, promotable integer type to an int
779 (FromType->isSignedIntegerType() ||
780 // We can promote any unsigned integer type whose size is
781 // less than int to an int.
Mike Stump11289f42009-09-09 15:08:12 +0000782 (!FromType->isSignedIntegerType() &&
Sebastian Redl72b8aef2008-10-31 14:43:28 +0000783 Context.getTypeSize(FromType) < Context.getTypeSize(ToType)))) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000784 return To->getKind() == BuiltinType::Int;
Sebastian Redl72b8aef2008-10-31 14:43:28 +0000785 }
786
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000787 return To->getKind() == BuiltinType::UInt;
788 }
789
790 // An rvalue of type wchar_t (3.9.1) or an enumeration type (7.2)
791 // can be converted to an rvalue of the first of the following types
792 // that can represent all the values of its underlying type: int,
793 // unsigned int, long, or unsigned long (C++ 4.5p2).
John McCall56774992009-12-09 09:09:27 +0000794
795 // We pre-calculate the promotion type for enum types.
796 if (const EnumType *FromEnumType = FromType->getAs<EnumType>())
797 if (ToType->isIntegerType())
798 return Context.hasSameUnqualifiedType(ToType,
799 FromEnumType->getDecl()->getPromotionType());
800
801 if (FromType->isWideCharType() && ToType->isIntegerType()) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000802 // Determine whether the type we're converting from is signed or
803 // unsigned.
804 bool FromIsSigned;
805 uint64_t FromSize = Context.getTypeSize(FromType);
John McCall56774992009-12-09 09:09:27 +0000806
807 // FIXME: Is wchar_t signed or unsigned? We assume it's signed for now.
808 FromIsSigned = true;
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000809
810 // The types we'll try to promote to, in the appropriate
811 // order. Try each of these types.
Mike Stump11289f42009-09-09 15:08:12 +0000812 QualType PromoteTypes[6] = {
813 Context.IntTy, Context.UnsignedIntTy,
Douglas Gregor1d248c52008-12-12 02:00:36 +0000814 Context.LongTy, Context.UnsignedLongTy ,
815 Context.LongLongTy, Context.UnsignedLongLongTy
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000816 };
Douglas Gregor1d248c52008-12-12 02:00:36 +0000817 for (int Idx = 0; Idx < 6; ++Idx) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000818 uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]);
819 if (FromSize < ToSize ||
Mike Stump11289f42009-09-09 15:08:12 +0000820 (FromSize == ToSize &&
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000821 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
822 // We found the type that we can promote to. If this is the
823 // type we wanted, we have a promotion. Otherwise, no
824 // promotion.
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +0000825 return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000826 }
827 }
828 }
829
830 // An rvalue for an integral bit-field (9.6) can be converted to an
831 // rvalue of type int if int can represent all the values of the
832 // bit-field; otherwise, it can be converted to unsigned int if
833 // unsigned int can represent all the values of the bit-field. If
834 // the bit-field is larger yet, no integral promotion applies to
835 // it. If the bit-field has an enumerated type, it is treated as any
836 // other value of that type for promotion purposes (C++ 4.5p3).
Mike Stump87c57ac2009-05-16 07:39:55 +0000837 // FIXME: We should delay checking of bit-fields until we actually perform the
838 // conversion.
Douglas Gregor71235ec2009-05-02 02:18:30 +0000839 using llvm::APSInt;
840 if (From)
841 if (FieldDecl *MemberDecl = From->getBitField()) {
Douglas Gregor2eedc3a2008-12-20 23:49:58 +0000842 APSInt BitWidth;
Douglas Gregor71235ec2009-05-02 02:18:30 +0000843 if (FromType->isIntegralType() && !FromType->isEnumeralType() &&
844 MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) {
845 APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned());
846 ToSize = Context.getTypeSize(ToType);
Mike Stump11289f42009-09-09 15:08:12 +0000847
Douglas Gregor2eedc3a2008-12-20 23:49:58 +0000848 // Are we promoting to an int from a bitfield that fits in an int?
849 if (BitWidth < ToSize ||
850 (FromType->isSignedIntegerType() && BitWidth <= ToSize)) {
851 return To->getKind() == BuiltinType::Int;
852 }
Mike Stump11289f42009-09-09 15:08:12 +0000853
Douglas Gregor2eedc3a2008-12-20 23:49:58 +0000854 // Are we promoting to an unsigned int from an unsigned bitfield
855 // that fits into an unsigned int?
856 if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) {
857 return To->getKind() == BuiltinType::UInt;
858 }
Mike Stump11289f42009-09-09 15:08:12 +0000859
Douglas Gregor2eedc3a2008-12-20 23:49:58 +0000860 return false;
Sebastian Redl72b8aef2008-10-31 14:43:28 +0000861 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000862 }
Mike Stump11289f42009-09-09 15:08:12 +0000863
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000864 // An rvalue of type bool can be converted to an rvalue of type int,
865 // with false becoming zero and true becoming one (C++ 4.5p4).
Sebastian Redl72b8aef2008-10-31 14:43:28 +0000866 if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000867 return true;
Sebastian Redl72b8aef2008-10-31 14:43:28 +0000868 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000869
870 return false;
871}
872
873/// IsFloatingPointPromotion - Determines whether the conversion from
874/// FromType to ToType is a floating point promotion (C++ 4.6). If so,
875/// returns true and sets PromotedType to the promoted type.
Mike Stump11289f42009-09-09 15:08:12 +0000876bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000877 /// An rvalue of type float can be converted to an rvalue of type
878 /// double. (C++ 4.6p1).
John McCall9dd450b2009-09-21 23:43:11 +0000879 if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
880 if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000881 if (FromBuiltin->getKind() == BuiltinType::Float &&
882 ToBuiltin->getKind() == BuiltinType::Double)
883 return true;
884
Douglas Gregor78ca74d2009-02-12 00:15:05 +0000885 // C99 6.3.1.5p1:
886 // When a float is promoted to double or long double, or a
887 // double is promoted to long double [...].
888 if (!getLangOptions().CPlusPlus &&
889 (FromBuiltin->getKind() == BuiltinType::Float ||
890 FromBuiltin->getKind() == BuiltinType::Double) &&
891 (ToBuiltin->getKind() == BuiltinType::LongDouble))
892 return true;
893 }
894
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000895 return false;
896}
897
Douglas Gregor78ca74d2009-02-12 00:15:05 +0000898/// \brief Determine if a conversion is a complex promotion.
899///
900/// A complex promotion is defined as a complex -> complex conversion
901/// where the conversion between the underlying real types is a
Douglas Gregor67525022009-02-12 00:26:06 +0000902/// floating-point or integral promotion.
Douglas Gregor78ca74d2009-02-12 00:15:05 +0000903bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
John McCall9dd450b2009-09-21 23:43:11 +0000904 const ComplexType *FromComplex = FromType->getAs<ComplexType>();
Douglas Gregor78ca74d2009-02-12 00:15:05 +0000905 if (!FromComplex)
906 return false;
907
John McCall9dd450b2009-09-21 23:43:11 +0000908 const ComplexType *ToComplex = ToType->getAs<ComplexType>();
Douglas Gregor78ca74d2009-02-12 00:15:05 +0000909 if (!ToComplex)
910 return false;
911
912 return IsFloatingPointPromotion(FromComplex->getElementType(),
Douglas Gregor67525022009-02-12 00:26:06 +0000913 ToComplex->getElementType()) ||
914 IsIntegralPromotion(0, FromComplex->getElementType(),
915 ToComplex->getElementType());
Douglas Gregor78ca74d2009-02-12 00:15:05 +0000916}
917
Douglas Gregor237f96c2008-11-26 23:31:11 +0000918/// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
919/// the pointer type FromPtr to a pointer to type ToPointee, with the
920/// same type qualifiers as FromPtr has on its pointee type. ToType,
921/// if non-empty, will be a pointer to ToType that may or may not have
922/// the right set of qualifiers on its pointee.
Mike Stump11289f42009-09-09 15:08:12 +0000923static QualType
924BuildSimilarlyQualifiedPointerType(const PointerType *FromPtr,
Douglas Gregor237f96c2008-11-26 23:31:11 +0000925 QualType ToPointee, QualType ToType,
926 ASTContext &Context) {
927 QualType CanonFromPointee = Context.getCanonicalType(FromPtr->getPointeeType());
928 QualType CanonToPointee = Context.getCanonicalType(ToPointee);
John McCall8ccfcb52009-09-24 19:53:00 +0000929 Qualifiers Quals = CanonFromPointee.getQualifiers();
Mike Stump11289f42009-09-09 15:08:12 +0000930
931 // Exact qualifier match -> return the pointer type we're converting to.
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +0000932 if (CanonToPointee.getLocalQualifiers() == Quals) {
Douglas Gregor237f96c2008-11-26 23:31:11 +0000933 // ToType is exactly what we need. Return it.
John McCall8ccfcb52009-09-24 19:53:00 +0000934 if (!ToType.isNull())
Douglas Gregor237f96c2008-11-26 23:31:11 +0000935 return ToType;
936
937 // Build a pointer to ToPointee. It has the right qualifiers
938 // already.
939 return Context.getPointerType(ToPointee);
940 }
941
942 // Just build a canonical type that has the right qualifiers.
John McCall8ccfcb52009-09-24 19:53:00 +0000943 return Context.getPointerType(
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +0000944 Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(),
945 Quals));
Douglas Gregor237f96c2008-11-26 23:31:11 +0000946}
947
Fariborz Jahanian01cbe442009-12-16 23:13:33 +0000948/// BuildSimilarlyQualifiedObjCObjectPointerType - In a pointer conversion from
949/// the FromType, which is an objective-c pointer, to ToType, which may or may
950/// not have the right set of qualifiers.
951static QualType
952BuildSimilarlyQualifiedObjCObjectPointerType(QualType FromType,
953 QualType ToType,
954 ASTContext &Context) {
955 QualType CanonFromType = Context.getCanonicalType(FromType);
956 QualType CanonToType = Context.getCanonicalType(ToType);
957 Qualifiers Quals = CanonFromType.getQualifiers();
958
959 // Exact qualifier match -> return the pointer type we're converting to.
960 if (CanonToType.getLocalQualifiers() == Quals)
961 return ToType;
962
963 // Just build a canonical type that has the right qualifiers.
964 return Context.getQualifiedType(CanonToType.getLocalUnqualifiedType(), Quals);
965}
966
Mike Stump11289f42009-09-09 15:08:12 +0000967static bool isNullPointerConstantForConversion(Expr *Expr,
Anders Carlsson759b7892009-08-28 15:55:56 +0000968 bool InOverloadResolution,
969 ASTContext &Context) {
970 // Handle value-dependent integral null pointer constants correctly.
971 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
972 if (Expr->isValueDependent() && !Expr->isTypeDependent() &&
973 Expr->getType()->isIntegralType())
974 return !InOverloadResolution;
975
Douglas Gregor56751b52009-09-25 04:25:58 +0000976 return Expr->isNullPointerConstant(Context,
977 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
978 : Expr::NPC_ValueDependentIsNull);
Anders Carlsson759b7892009-08-28 15:55:56 +0000979}
Mike Stump11289f42009-09-09 15:08:12 +0000980
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000981/// IsPointerConversion - Determines whether the conversion of the
982/// expression From, which has the (possibly adjusted) type FromType,
983/// can be converted to the type ToType via a pointer conversion (C++
984/// 4.10). If so, returns true and places the converted type (that
985/// might differ from ToType in its cv-qualifiers at some level) into
986/// ConvertedType.
Douglas Gregor231d1c62008-11-27 00:15:41 +0000987///
Douglas Gregora29dc052008-11-27 01:19:21 +0000988/// This routine also supports conversions to and from block pointers
989/// and conversions with Objective-C's 'id', 'id<protocols...>', and
990/// pointers to interfaces. FIXME: Once we've determined the
991/// appropriate overloading rules for Objective-C, we may want to
992/// split the Objective-C checks into a different routine; however,
993/// GCC seems to consider all of these conversions to be pointer
Douglas Gregor47d3f272008-12-19 17:40:08 +0000994/// conversions, so for now they live here. IncompatibleObjC will be
995/// set if the conversion is an allowed Objective-C conversion that
996/// should result in a warning.
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000997bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
Anders Carlsson228eea32009-08-28 15:33:32 +0000998 bool InOverloadResolution,
Douglas Gregor47d3f272008-12-19 17:40:08 +0000999 QualType& ConvertedType,
Mike Stump11289f42009-09-09 15:08:12 +00001000 bool &IncompatibleObjC) {
Douglas Gregor47d3f272008-12-19 17:40:08 +00001001 IncompatibleObjC = false;
Douglas Gregora119f102008-12-19 19:13:09 +00001002 if (isObjCPointerConversion(FromType, ToType, ConvertedType, IncompatibleObjC))
1003 return true;
Douglas Gregor47d3f272008-12-19 17:40:08 +00001004
Mike Stump11289f42009-09-09 15:08:12 +00001005 // Conversion from a null pointer constant to any Objective-C pointer type.
1006 if (ToType->isObjCObjectPointerType() &&
Anders Carlsson759b7892009-08-28 15:55:56 +00001007 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
Douglas Gregor79a6b012008-12-22 20:51:52 +00001008 ConvertedType = ToType;
1009 return true;
1010 }
1011
Douglas Gregor231d1c62008-11-27 00:15:41 +00001012 // Blocks: Block pointers can be converted to void*.
1013 if (FromType->isBlockPointerType() && ToType->isPointerType() &&
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001014 ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
Douglas Gregor231d1c62008-11-27 00:15:41 +00001015 ConvertedType = ToType;
1016 return true;
1017 }
1018 // Blocks: A null pointer constant can be converted to a block
1019 // pointer type.
Mike Stump11289f42009-09-09 15:08:12 +00001020 if (ToType->isBlockPointerType() &&
Anders Carlsson759b7892009-08-28 15:55:56 +00001021 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
Douglas Gregor231d1c62008-11-27 00:15:41 +00001022 ConvertedType = ToType;
1023 return true;
1024 }
1025
Sebastian Redl576fd422009-05-10 18:38:11 +00001026 // If the left-hand-side is nullptr_t, the right side can be a null
1027 // pointer constant.
Mike Stump11289f42009-09-09 15:08:12 +00001028 if (ToType->isNullPtrType() &&
Anders Carlsson759b7892009-08-28 15:55:56 +00001029 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
Sebastian Redl576fd422009-05-10 18:38:11 +00001030 ConvertedType = ToType;
1031 return true;
1032 }
1033
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001034 const PointerType* ToTypePtr = ToType->getAs<PointerType>();
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001035 if (!ToTypePtr)
1036 return false;
1037
1038 // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
Anders Carlsson759b7892009-08-28 15:55:56 +00001039 if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001040 ConvertedType = ToType;
1041 return true;
1042 }
Sebastian Redl72b8aef2008-10-31 14:43:28 +00001043
Fariborz Jahanian01cbe442009-12-16 23:13:33 +00001044 // Beyond this point, both types need to be pointers
1045 // , including objective-c pointers.
1046 QualType ToPointeeType = ToTypePtr->getPointeeType();
1047 if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType()) {
1048 ConvertedType = BuildSimilarlyQualifiedObjCObjectPointerType(FromType,
1049 ToType, Context);
1050 return true;
1051
1052 }
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001053 const PointerType *FromTypePtr = FromType->getAs<PointerType>();
Douglas Gregor237f96c2008-11-26 23:31:11 +00001054 if (!FromTypePtr)
1055 return false;
1056
1057 QualType FromPointeeType = FromTypePtr->getPointeeType();
Douglas Gregor237f96c2008-11-26 23:31:11 +00001058
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001059 // An rvalue of type "pointer to cv T," where T is an object type,
1060 // can be converted to an rvalue of type "pointer to cv void" (C++
1061 // 4.10p2).
Douglas Gregor64259f52009-03-24 20:32:41 +00001062 if (FromPointeeType->isObjectType() && ToPointeeType->isVoidType()) {
Mike Stump11289f42009-09-09 15:08:12 +00001063 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
Douglas Gregorbb9bf882008-11-27 00:52:49 +00001064 ToPointeeType,
Douglas Gregor237f96c2008-11-26 23:31:11 +00001065 ToType, Context);
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001066 return true;
1067 }
1068
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00001069 // When we're overloading in C, we allow a special kind of pointer
1070 // conversion for compatible-but-not-identical pointee types.
Mike Stump11289f42009-09-09 15:08:12 +00001071 if (!getLangOptions().CPlusPlus &&
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00001072 Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
Mike Stump11289f42009-09-09 15:08:12 +00001073 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00001074 ToPointeeType,
Mike Stump11289f42009-09-09 15:08:12 +00001075 ToType, Context);
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00001076 return true;
1077 }
1078
Douglas Gregor5c407d92008-10-23 00:40:37 +00001079 // C++ [conv.ptr]p3:
Mike Stump11289f42009-09-09 15:08:12 +00001080 //
Douglas Gregor5c407d92008-10-23 00:40:37 +00001081 // An rvalue of type "pointer to cv D," where D is a class type,
1082 // can be converted to an rvalue of type "pointer to cv B," where
1083 // B is a base class (clause 10) of D. If B is an inaccessible
1084 // (clause 11) or ambiguous (10.2) base class of D, a program that
1085 // necessitates this conversion is ill-formed. The result of the
1086 // conversion is a pointer to the base class sub-object of the
1087 // derived class object. The null pointer value is converted to
1088 // the null pointer value of the destination type.
1089 //
Douglas Gregor39c16d42008-10-24 04:54:22 +00001090 // Note that we do not check for ambiguity or inaccessibility
1091 // here. That is handled by CheckPointerConversion.
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00001092 if (getLangOptions().CPlusPlus &&
1093 FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
Douglas Gregord28f0412010-02-22 17:06:41 +00001094 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) &&
Douglas Gregore6fb91f2009-10-29 23:08:22 +00001095 !RequireCompleteType(From->getLocStart(), FromPointeeType, PDiag()) &&
Douglas Gregor237f96c2008-11-26 23:31:11 +00001096 IsDerivedFrom(FromPointeeType, ToPointeeType)) {
Mike Stump11289f42009-09-09 15:08:12 +00001097 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
Douglas Gregorbb9bf882008-11-27 00:52:49 +00001098 ToPointeeType,
Douglas Gregor237f96c2008-11-26 23:31:11 +00001099 ToType, Context);
1100 return true;
1101 }
Douglas Gregor5c407d92008-10-23 00:40:37 +00001102
Douglas Gregora119f102008-12-19 19:13:09 +00001103 return false;
1104}
1105
1106/// isObjCPointerConversion - Determines whether this is an
1107/// Objective-C pointer conversion. Subroutine of IsPointerConversion,
1108/// with the same arguments and return values.
Mike Stump11289f42009-09-09 15:08:12 +00001109bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
Douglas Gregora119f102008-12-19 19:13:09 +00001110 QualType& ConvertedType,
1111 bool &IncompatibleObjC) {
1112 if (!getLangOptions().ObjC1)
1113 return false;
Fariborz Jahanian42ffdb32010-01-18 22:59:22 +00001114
Steve Naroff7cae42b2009-07-10 23:34:53 +00001115 // First, we handle all conversions on ObjC object pointer types.
John McCall9dd450b2009-09-21 23:43:11 +00001116 const ObjCObjectPointerType* ToObjCPtr = ToType->getAs<ObjCObjectPointerType>();
Mike Stump11289f42009-09-09 15:08:12 +00001117 const ObjCObjectPointerType *FromObjCPtr =
John McCall9dd450b2009-09-21 23:43:11 +00001118 FromType->getAs<ObjCObjectPointerType>();
Douglas Gregora119f102008-12-19 19:13:09 +00001119
Steve Naroff7cae42b2009-07-10 23:34:53 +00001120 if (ToObjCPtr && FromObjCPtr) {
Steve Naroff1329fa02009-07-15 18:40:39 +00001121 // Objective C++: We're able to convert between "id" or "Class" and a
Steve Naroff7cae42b2009-07-10 23:34:53 +00001122 // pointer to any interface (in both directions).
Steve Naroff1329fa02009-07-15 18:40:39 +00001123 if (ToObjCPtr->isObjCBuiltinType() && FromObjCPtr->isObjCBuiltinType()) {
Steve Naroff7cae42b2009-07-10 23:34:53 +00001124 ConvertedType = ToType;
1125 return true;
1126 }
1127 // Conversions with Objective-C's id<...>.
Mike Stump11289f42009-09-09 15:08:12 +00001128 if ((FromObjCPtr->isObjCQualifiedIdType() ||
Steve Naroff7cae42b2009-07-10 23:34:53 +00001129 ToObjCPtr->isObjCQualifiedIdType()) &&
Mike Stump11289f42009-09-09 15:08:12 +00001130 Context.ObjCQualifiedIdTypesAreCompatible(ToType, FromType,
Steve Naroff8e6aee52009-07-23 01:01:38 +00001131 /*compare=*/false)) {
Steve Naroff7cae42b2009-07-10 23:34:53 +00001132 ConvertedType = ToType;
1133 return true;
1134 }
1135 // Objective C++: We're able to convert from a pointer to an
1136 // interface to a pointer to a different interface.
1137 if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
1138 ConvertedType = ToType;
1139 return true;
1140 }
1141
1142 if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
1143 // Okay: this is some kind of implicit downcast of Objective-C
1144 // interfaces, which is permitted. However, we're going to
1145 // complain about it.
1146 IncompatibleObjC = true;
1147 ConvertedType = FromType;
1148 return true;
1149 }
Mike Stump11289f42009-09-09 15:08:12 +00001150 }
Steve Naroff7cae42b2009-07-10 23:34:53 +00001151 // Beyond this point, both types need to be C pointers or block pointers.
Douglas Gregor033f56d2008-12-23 00:53:59 +00001152 QualType ToPointeeType;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001153 if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
Steve Naroff7cae42b2009-07-10 23:34:53 +00001154 ToPointeeType = ToCPtr->getPointeeType();
Fariborz Jahanian4efdec02010-01-20 22:54:38 +00001155 else if (const BlockPointerType *ToBlockPtr =
1156 ToType->getAs<BlockPointerType>()) {
Fariborz Jahanian879cc732010-01-21 00:08:17 +00001157 // Objective C++: We're able to convert from a pointer to any object
Fariborz Jahanian4efdec02010-01-20 22:54:38 +00001158 // to a block pointer type.
1159 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
1160 ConvertedType = ToType;
1161 return true;
1162 }
Douglas Gregor033f56d2008-12-23 00:53:59 +00001163 ToPointeeType = ToBlockPtr->getPointeeType();
Fariborz Jahanian4efdec02010-01-20 22:54:38 +00001164 }
Fariborz Jahaniane4951fd2010-01-21 00:05:09 +00001165 else if (FromType->getAs<BlockPointerType>() &&
1166 ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) {
1167 // Objective C++: We're able to convert from a block pointer type to a
Fariborz Jahanian879cc732010-01-21 00:08:17 +00001168 // pointer to any object.
Fariborz Jahaniane4951fd2010-01-21 00:05:09 +00001169 ConvertedType = ToType;
1170 return true;
1171 }
Douglas Gregor033f56d2008-12-23 00:53:59 +00001172 else
Douglas Gregora119f102008-12-19 19:13:09 +00001173 return false;
1174
Douglas Gregor033f56d2008-12-23 00:53:59 +00001175 QualType FromPointeeType;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001176 if (const PointerType *FromCPtr = FromType->getAs<PointerType>())
Steve Naroff7cae42b2009-07-10 23:34:53 +00001177 FromPointeeType = FromCPtr->getPointeeType();
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001178 else if (const BlockPointerType *FromBlockPtr = FromType->getAs<BlockPointerType>())
Douglas Gregor033f56d2008-12-23 00:53:59 +00001179 FromPointeeType = FromBlockPtr->getPointeeType();
1180 else
Douglas Gregora119f102008-12-19 19:13:09 +00001181 return false;
1182
Douglas Gregora119f102008-12-19 19:13:09 +00001183 // If we have pointers to pointers, recursively check whether this
1184 // is an Objective-C conversion.
1185 if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() &&
1186 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
1187 IncompatibleObjC)) {
1188 // We always complain about this conversion.
1189 IncompatibleObjC = true;
1190 ConvertedType = ToType;
1191 return true;
1192 }
Fariborz Jahanian42ffdb32010-01-18 22:59:22 +00001193 // Allow conversion of pointee being objective-c pointer to another one;
1194 // as in I* to id.
1195 if (FromPointeeType->getAs<ObjCObjectPointerType>() &&
1196 ToPointeeType->getAs<ObjCObjectPointerType>() &&
1197 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
1198 IncompatibleObjC)) {
1199 ConvertedType = ToType;
1200 return true;
1201 }
1202
Douglas Gregor033f56d2008-12-23 00:53:59 +00001203 // If we have pointers to functions or blocks, check whether the only
Douglas Gregora119f102008-12-19 19:13:09 +00001204 // differences in the argument and result types are in Objective-C
1205 // pointer conversions. If so, we permit the conversion (but
1206 // complain about it).
Mike Stump11289f42009-09-09 15:08:12 +00001207 const FunctionProtoType *FromFunctionType
John McCall9dd450b2009-09-21 23:43:11 +00001208 = FromPointeeType->getAs<FunctionProtoType>();
Douglas Gregordeaad8c2009-02-26 23:50:07 +00001209 const FunctionProtoType *ToFunctionType
John McCall9dd450b2009-09-21 23:43:11 +00001210 = ToPointeeType->getAs<FunctionProtoType>();
Douglas Gregora119f102008-12-19 19:13:09 +00001211 if (FromFunctionType && ToFunctionType) {
1212 // If the function types are exactly the same, this isn't an
1213 // Objective-C pointer conversion.
1214 if (Context.getCanonicalType(FromPointeeType)
1215 == Context.getCanonicalType(ToPointeeType))
1216 return false;
1217
1218 // Perform the quick checks that will tell us whether these
1219 // function types are obviously different.
1220 if (FromFunctionType->getNumArgs() != ToFunctionType->getNumArgs() ||
1221 FromFunctionType->isVariadic() != ToFunctionType->isVariadic() ||
1222 FromFunctionType->getTypeQuals() != ToFunctionType->getTypeQuals())
1223 return false;
1224
1225 bool HasObjCConversion = false;
1226 if (Context.getCanonicalType(FromFunctionType->getResultType())
1227 == Context.getCanonicalType(ToFunctionType->getResultType())) {
1228 // Okay, the types match exactly. Nothing to do.
1229 } else if (isObjCPointerConversion(FromFunctionType->getResultType(),
1230 ToFunctionType->getResultType(),
1231 ConvertedType, IncompatibleObjC)) {
1232 // Okay, we have an Objective-C pointer conversion.
1233 HasObjCConversion = true;
1234 } else {
1235 // Function types are too different. Abort.
1236 return false;
1237 }
Mike Stump11289f42009-09-09 15:08:12 +00001238
Douglas Gregora119f102008-12-19 19:13:09 +00001239 // Check argument types.
1240 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs();
1241 ArgIdx != NumArgs; ++ArgIdx) {
1242 QualType FromArgType = FromFunctionType->getArgType(ArgIdx);
1243 QualType ToArgType = ToFunctionType->getArgType(ArgIdx);
1244 if (Context.getCanonicalType(FromArgType)
1245 == Context.getCanonicalType(ToArgType)) {
1246 // Okay, the types match exactly. Nothing to do.
1247 } else if (isObjCPointerConversion(FromArgType, ToArgType,
1248 ConvertedType, IncompatibleObjC)) {
1249 // Okay, we have an Objective-C pointer conversion.
1250 HasObjCConversion = true;
1251 } else {
1252 // Argument types are too different. Abort.
1253 return false;
1254 }
1255 }
1256
1257 if (HasObjCConversion) {
1258 // We had an Objective-C conversion. Allow this pointer
1259 // conversion, but complain about it.
1260 ConvertedType = ToType;
1261 IncompatibleObjC = true;
1262 return true;
1263 }
1264 }
1265
Sebastian Redl72b597d2009-01-25 19:43:20 +00001266 return false;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001267}
1268
Douglas Gregor39c16d42008-10-24 04:54:22 +00001269/// CheckPointerConversion - Check the pointer conversion from the
1270/// expression From to the type ToType. This routine checks for
Sebastian Redl9f831db2009-07-25 15:41:38 +00001271/// ambiguous or inaccessible derived-to-base pointer
Douglas Gregor39c16d42008-10-24 04:54:22 +00001272/// conversions for which IsPointerConversion has already returned
1273/// true. It returns true and produces a diagnostic if there was an
1274/// error, or returns false otherwise.
Anders Carlsson7ec8ccd2009-09-12 04:46:44 +00001275bool Sema::CheckPointerConversion(Expr *From, QualType ToType,
Sebastian Redl7c353682009-11-14 21:15:49 +00001276 CastExpr::CastKind &Kind,
1277 bool IgnoreBaseAccess) {
Douglas Gregor39c16d42008-10-24 04:54:22 +00001278 QualType FromType = From->getType();
1279
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001280 if (const PointerType *FromPtrType = FromType->getAs<PointerType>())
1281 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
Douglas Gregor39c16d42008-10-24 04:54:22 +00001282 QualType FromPointeeType = FromPtrType->getPointeeType(),
1283 ToPointeeType = ToPtrType->getPointeeType();
Douglas Gregor1e57a3f2008-12-18 23:43:31 +00001284
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001285 if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
1286 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {
Douglas Gregor39c16d42008-10-24 04:54:22 +00001287 // We must have a derived-to-base conversion. Check an
1288 // ambiguous or inaccessible conversion.
Anders Carlsson7ec8ccd2009-09-12 04:46:44 +00001289 if (CheckDerivedToBaseConversion(FromPointeeType, ToPointeeType,
1290 From->getExprLoc(),
Sebastian Redl7c353682009-11-14 21:15:49 +00001291 From->getSourceRange(),
1292 IgnoreBaseAccess))
Anders Carlsson7ec8ccd2009-09-12 04:46:44 +00001293 return true;
1294
1295 // The conversion was successful.
1296 Kind = CastExpr::CK_DerivedToBase;
Douglas Gregor39c16d42008-10-24 04:54:22 +00001297 }
1298 }
Mike Stump11289f42009-09-09 15:08:12 +00001299 if (const ObjCObjectPointerType *FromPtrType =
John McCall9dd450b2009-09-21 23:43:11 +00001300 FromType->getAs<ObjCObjectPointerType>())
Mike Stump11289f42009-09-09 15:08:12 +00001301 if (const ObjCObjectPointerType *ToPtrType =
John McCall9dd450b2009-09-21 23:43:11 +00001302 ToType->getAs<ObjCObjectPointerType>()) {
Steve Naroff7cae42b2009-07-10 23:34:53 +00001303 // Objective-C++ conversions are always okay.
1304 // FIXME: We should have a different class of conversions for the
1305 // Objective-C++ implicit conversions.
Steve Naroff1329fa02009-07-15 18:40:39 +00001306 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
Steve Naroff7cae42b2009-07-10 23:34:53 +00001307 return false;
Douglas Gregor39c16d42008-10-24 04:54:22 +00001308
Steve Naroff7cae42b2009-07-10 23:34:53 +00001309 }
Douglas Gregor39c16d42008-10-24 04:54:22 +00001310 return false;
1311}
1312
Sebastian Redl72b597d2009-01-25 19:43:20 +00001313/// IsMemberPointerConversion - Determines whether the conversion of the
1314/// expression From, which has the (possibly adjusted) type FromType, can be
1315/// converted to the type ToType via a member pointer conversion (C++ 4.11).
1316/// If so, returns true and places the converted type (that might differ from
1317/// ToType in its cv-qualifiers at some level) into ConvertedType.
1318bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType,
Douglas Gregor56751b52009-09-25 04:25:58 +00001319 QualType ToType,
1320 bool InOverloadResolution,
1321 QualType &ConvertedType) {
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001322 const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
Sebastian Redl72b597d2009-01-25 19:43:20 +00001323 if (!ToTypePtr)
1324 return false;
1325
1326 // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
Douglas Gregor56751b52009-09-25 04:25:58 +00001327 if (From->isNullPointerConstant(Context,
1328 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
1329 : Expr::NPC_ValueDependentIsNull)) {
Sebastian Redl72b597d2009-01-25 19:43:20 +00001330 ConvertedType = ToType;
1331 return true;
1332 }
1333
1334 // Otherwise, both types have to be member pointers.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001335 const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>();
Sebastian Redl72b597d2009-01-25 19:43:20 +00001336 if (!FromTypePtr)
1337 return false;
1338
1339 // A pointer to member of B can be converted to a pointer to member of D,
1340 // where D is derived from B (C++ 4.11p2).
1341 QualType FromClass(FromTypePtr->getClass(), 0);
1342 QualType ToClass(ToTypePtr->getClass(), 0);
1343 // FIXME: What happens when these are dependent? Is this function even called?
1344
1345 if (IsDerivedFrom(ToClass, FromClass)) {
1346 ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(),
1347 ToClass.getTypePtr());
1348 return true;
1349 }
1350
1351 return false;
1352}
Douglas Gregor40cb9ad2009-12-09 00:47:37 +00001353
Sebastian Redl72b597d2009-01-25 19:43:20 +00001354/// CheckMemberPointerConversion - Check the member pointer conversion from the
1355/// expression From to the type ToType. This routine checks for ambiguous or
John McCall5b0829a2010-02-10 09:31:12 +00001356/// virtual or inaccessible base-to-derived member pointer conversions
Sebastian Redl72b597d2009-01-25 19:43:20 +00001357/// for which IsMemberPointerConversion has already returned true. It returns
1358/// true and produces a diagnostic if there was an error, or returns false
1359/// otherwise.
Mike Stump11289f42009-09-09 15:08:12 +00001360bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
Sebastian Redl7c353682009-11-14 21:15:49 +00001361 CastExpr::CastKind &Kind,
1362 bool IgnoreBaseAccess) {
Sebastian Redl72b597d2009-01-25 19:43:20 +00001363 QualType FromType = From->getType();
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001364 const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
Anders Carlssond7923c62009-08-22 23:33:40 +00001365 if (!FromPtrType) {
1366 // This must be a null pointer to member pointer conversion
Douglas Gregor56751b52009-09-25 04:25:58 +00001367 assert(From->isNullPointerConstant(Context,
1368 Expr::NPC_ValueDependentIsNull) &&
Anders Carlssond7923c62009-08-22 23:33:40 +00001369 "Expr must be null pointer constant!");
1370 Kind = CastExpr::CK_NullToMemberPointer;
Sebastian Redled8f2002009-01-28 18:33:18 +00001371 return false;
Anders Carlssond7923c62009-08-22 23:33:40 +00001372 }
Sebastian Redl72b597d2009-01-25 19:43:20 +00001373
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001374 const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
Sebastian Redled8f2002009-01-28 18:33:18 +00001375 assert(ToPtrType && "No member pointer cast has a target type "
1376 "that is not a member pointer.");
Sebastian Redl72b597d2009-01-25 19:43:20 +00001377
Sebastian Redled8f2002009-01-28 18:33:18 +00001378 QualType FromClass = QualType(FromPtrType->getClass(), 0);
1379 QualType ToClass = QualType(ToPtrType->getClass(), 0);
Sebastian Redl72b597d2009-01-25 19:43:20 +00001380
Sebastian Redled8f2002009-01-28 18:33:18 +00001381 // FIXME: What about dependent types?
1382 assert(FromClass->isRecordType() && "Pointer into non-class.");
1383 assert(ToClass->isRecordType() && "Pointer into non-class.");
Sebastian Redl72b597d2009-01-25 19:43:20 +00001384
John McCall5b0829a2010-02-10 09:31:12 +00001385 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/ true,
Douglas Gregor36d1b142009-10-06 17:59:45 +00001386 /*DetectVirtual=*/true);
Sebastian Redled8f2002009-01-28 18:33:18 +00001387 bool DerivationOkay = IsDerivedFrom(ToClass, FromClass, Paths);
1388 assert(DerivationOkay &&
1389 "Should not have been called if derivation isn't OK.");
1390 (void)DerivationOkay;
Sebastian Redl72b597d2009-01-25 19:43:20 +00001391
Sebastian Redled8f2002009-01-28 18:33:18 +00001392 if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
1393 getUnqualifiedType())) {
Sebastian Redled8f2002009-01-28 18:33:18 +00001394 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
1395 Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
1396 << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
1397 return true;
Sebastian Redl72b597d2009-01-25 19:43:20 +00001398 }
Sebastian Redled8f2002009-01-28 18:33:18 +00001399
Douglas Gregor89ee6822009-02-28 01:32:25 +00001400 if (const RecordType *VBase = Paths.getDetectedVirtual()) {
Sebastian Redled8f2002009-01-28 18:33:18 +00001401 Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
1402 << FromClass << ToClass << QualType(VBase, 0)
1403 << From->getSourceRange();
1404 return true;
1405 }
1406
John McCall5b0829a2010-02-10 09:31:12 +00001407 if (!IgnoreBaseAccess)
1408 CheckBaseClassAccess(From->getExprLoc(), /*BaseToDerived*/ true,
1409 FromClass, ToClass, Paths.front());
1410
Anders Carlssond7923c62009-08-22 23:33:40 +00001411 // Must be a base to derived member conversion.
1412 Kind = CastExpr::CK_BaseToDerivedMemberPointer;
Sebastian Redl72b597d2009-01-25 19:43:20 +00001413 return false;
1414}
1415
Douglas Gregor9a657932008-10-21 23:43:52 +00001416/// IsQualificationConversion - Determines whether the conversion from
1417/// an rvalue of type FromType to ToType is a qualification conversion
1418/// (C++ 4.4).
Mike Stump11289f42009-09-09 15:08:12 +00001419bool
1420Sema::IsQualificationConversion(QualType FromType, QualType ToType) {
Douglas Gregor9a657932008-10-21 23:43:52 +00001421 FromType = Context.getCanonicalType(FromType);
1422 ToType = Context.getCanonicalType(ToType);
1423
1424 // If FromType and ToType are the same type, this is not a
1425 // qualification conversion.
Sebastian Redlcbdffb12010-02-03 19:36:07 +00001426 if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
Douglas Gregor9a657932008-10-21 23:43:52 +00001427 return false;
Sebastian Redled8f2002009-01-28 18:33:18 +00001428
Douglas Gregor9a657932008-10-21 23:43:52 +00001429 // (C++ 4.4p4):
1430 // A conversion can add cv-qualifiers at levels other than the first
1431 // in multi-level pointers, subject to the following rules: [...]
1432 bool PreviousToQualsIncludeConst = true;
Douglas Gregor9a657932008-10-21 23:43:52 +00001433 bool UnwrappedAnyPointer = false;
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001434 while (UnwrapSimilarPointerTypes(FromType, ToType)) {
Douglas Gregor9a657932008-10-21 23:43:52 +00001435 // Within each iteration of the loop, we check the qualifiers to
1436 // determine if this still looks like a qualification
1437 // conversion. Then, if all is well, we unwrap one more level of
Douglas Gregor29a92472008-10-22 17:49:05 +00001438 // pointers or pointers-to-members and do it all again
Douglas Gregor9a657932008-10-21 23:43:52 +00001439 // until there are no more pointers or pointers-to-members left to
1440 // unwrap.
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001441 UnwrappedAnyPointer = true;
Douglas Gregor9a657932008-10-21 23:43:52 +00001442
1443 // -- for every j > 0, if const is in cv 1,j then const is in cv
1444 // 2,j, and similarly for volatile.
Douglas Gregorea2d4212008-10-22 00:38:21 +00001445 if (!ToType.isAtLeastAsQualifiedAs(FromType))
Douglas Gregor9a657932008-10-21 23:43:52 +00001446 return false;
Mike Stump11289f42009-09-09 15:08:12 +00001447
Douglas Gregor9a657932008-10-21 23:43:52 +00001448 // -- if the cv 1,j and cv 2,j are different, then const is in
1449 // every cv for 0 < k < j.
1450 if (FromType.getCVRQualifiers() != ToType.getCVRQualifiers()
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001451 && !PreviousToQualsIncludeConst)
Douglas Gregor9a657932008-10-21 23:43:52 +00001452 return false;
Mike Stump11289f42009-09-09 15:08:12 +00001453
Douglas Gregor9a657932008-10-21 23:43:52 +00001454 // Keep track of whether all prior cv-qualifiers in the "to" type
1455 // include const.
Mike Stump11289f42009-09-09 15:08:12 +00001456 PreviousToQualsIncludeConst
Douglas Gregor9a657932008-10-21 23:43:52 +00001457 = PreviousToQualsIncludeConst && ToType.isConstQualified();
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001458 }
Douglas Gregor9a657932008-10-21 23:43:52 +00001459
1460 // We are left with FromType and ToType being the pointee types
1461 // after unwrapping the original FromType and ToType the same number
1462 // of types. If we unwrapped any pointers, and if FromType and
1463 // ToType have the same unqualified type (since we checked
1464 // qualifiers above), then this is a qualification conversion.
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00001465 return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
Douglas Gregor9a657932008-10-21 23:43:52 +00001466}
1467
Douglas Gregor576e98c2009-01-30 23:27:23 +00001468/// Determines whether there is a user-defined conversion sequence
1469/// (C++ [over.ics.user]) that converts expression From to the type
1470/// ToType. If such a conversion exists, User will contain the
1471/// user-defined conversion sequence that performs such a conversion
1472/// and this routine will return true. Otherwise, this routine returns
1473/// false and User is unspecified.
1474///
1475/// \param AllowConversionFunctions true if the conversion should
1476/// consider conversion functions at all. If false, only constructors
1477/// will be considered.
1478///
1479/// \param AllowExplicit true if the conversion should consider C++0x
1480/// "explicit" conversion functions as well as non-explicit conversion
1481/// functions (C++0x [class.conv.fct]p2).
Sebastian Redl42e92c42009-04-12 17:16:29 +00001482///
1483/// \param ForceRValue true if the expression should be treated as an rvalue
1484/// for overload resolution.
Fariborz Jahanianb3c44f92009-10-01 20:39:51 +00001485/// \param UserCast true if looking for user defined conversion for a static
1486/// cast.
Douglas Gregor3e1e5272009-12-09 23:02:17 +00001487OverloadingResult Sema::IsUserDefinedConversion(Expr *From, QualType ToType,
1488 UserDefinedConversionSequence& User,
1489 OverloadCandidateSet& CandidateSet,
1490 bool AllowConversionFunctions,
1491 bool AllowExplicit,
1492 bool ForceRValue,
1493 bool UserCast) {
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001494 if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
Douglas Gregor3ec1bf22009-11-05 13:06:35 +00001495 if (RequireCompleteType(From->getLocStart(), ToType, PDiag())) {
1496 // We're not going to find any constructors.
1497 } else if (CXXRecordDecl *ToRecordDecl
1498 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
Douglas Gregor89ee6822009-02-28 01:32:25 +00001499 // C++ [over.match.ctor]p1:
1500 // When objects of class type are direct-initialized (8.5), or
1501 // copy-initialized from an expression of the same or a
1502 // derived class type (8.5), overload resolution selects the
1503 // constructor. [...] For copy-initialization, the candidate
1504 // functions are all the converting constructors (12.3.1) of
1505 // that class. The argument list is the expression-list within
1506 // the parentheses of the initializer.
Douglas Gregor379d84b2009-11-13 18:44:21 +00001507 bool SuppressUserConversions = !UserCast;
1508 if (Context.hasSameUnqualifiedType(ToType, From->getType()) ||
1509 IsDerivedFrom(From->getType(), ToType)) {
1510 SuppressUserConversions = false;
1511 AllowConversionFunctions = false;
1512 }
1513
Mike Stump11289f42009-09-09 15:08:12 +00001514 DeclarationName ConstructorName
Douglas Gregor89ee6822009-02-28 01:32:25 +00001515 = Context.DeclarationNames.getCXXConstructorName(
1516 Context.getCanonicalType(ToType).getUnqualifiedType());
1517 DeclContext::lookup_iterator Con, ConEnd;
Mike Stump11289f42009-09-09 15:08:12 +00001518 for (llvm::tie(Con, ConEnd)
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00001519 = ToRecordDecl->lookup(ConstructorName);
Douglas Gregor89ee6822009-02-28 01:32:25 +00001520 Con != ConEnd; ++Con) {
Douglas Gregor5ed5ae42009-08-21 18:42:58 +00001521 // Find the constructor (which may be a template).
1522 CXXConstructorDecl *Constructor = 0;
1523 FunctionTemplateDecl *ConstructorTmpl
1524 = dyn_cast<FunctionTemplateDecl>(*Con);
1525 if (ConstructorTmpl)
Mike Stump11289f42009-09-09 15:08:12 +00001526 Constructor
Douglas Gregor5ed5ae42009-08-21 18:42:58 +00001527 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
1528 else
1529 Constructor = cast<CXXConstructorDecl>(*Con);
Douglas Gregorffe14e32009-11-14 01:20:54 +00001530
Fariborz Jahanian11a8e952009-08-06 17:22:51 +00001531 if (!Constructor->isInvalidDecl() &&
Anders Carlssond20e7952009-08-28 16:57:08 +00001532 Constructor->isConvertingConstructor(AllowExplicit)) {
Douglas Gregor5ed5ae42009-08-21 18:42:58 +00001533 if (ConstructorTmpl)
John McCallb89836b2010-01-26 01:37:31 +00001534 AddTemplateOverloadCandidate(ConstructorTmpl,
1535 ConstructorTmpl->getAccess(),
1536 /*ExplicitArgs*/ 0,
John McCall6b51f282009-11-23 01:53:49 +00001537 &From, 1, CandidateSet,
Douglas Gregor379d84b2009-11-13 18:44:21 +00001538 SuppressUserConversions, ForceRValue);
Douglas Gregor5ed5ae42009-08-21 18:42:58 +00001539 else
Fariborz Jahanianb3c44f92009-10-01 20:39:51 +00001540 // Allow one user-defined conversion when user specifies a
1541 // From->ToType conversion via an static cast (c-style, etc).
John McCallb89836b2010-01-26 01:37:31 +00001542 AddOverloadCandidate(Constructor, Constructor->getAccess(),
1543 &From, 1, CandidateSet,
Douglas Gregor379d84b2009-11-13 18:44:21 +00001544 SuppressUserConversions, ForceRValue);
Douglas Gregor5ed5ae42009-08-21 18:42:58 +00001545 }
Douglas Gregor89ee6822009-02-28 01:32:25 +00001546 }
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001547 }
1548 }
1549
Douglas Gregor576e98c2009-01-30 23:27:23 +00001550 if (!AllowConversionFunctions) {
1551 // Don't allow any conversion functions to enter the overload set.
Mike Stump11289f42009-09-09 15:08:12 +00001552 } else if (RequireCompleteType(From->getLocStart(), From->getType(),
1553 PDiag(0)
Anders Carlssond624e162009-08-26 23:45:07 +00001554 << From->getSourceRange())) {
Douglas Gregor8a2e6012009-08-24 15:23:48 +00001555 // No conversion functions from incomplete types.
Mike Stump11289f42009-09-09 15:08:12 +00001556 } else if (const RecordType *FromRecordType
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001557 = From->getType()->getAs<RecordType>()) {
Mike Stump11289f42009-09-09 15:08:12 +00001558 if (CXXRecordDecl *FromRecordDecl
Fariborz Jahanianf9012a32009-09-11 18:46:22 +00001559 = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
1560 // Add all of the conversion functions as candidates.
John McCallad371252010-01-20 00:46:10 +00001561 const UnresolvedSetImpl *Conversions
Fariborz Jahanianf4061e32009-09-14 20:41:01 +00001562 = FromRecordDecl->getVisibleConversionFunctions();
John McCallad371252010-01-20 00:46:10 +00001563 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
John McCalld14a8642009-11-21 08:51:07 +00001564 E = Conversions->end(); I != E; ++I) {
John McCall6e9f8f62009-12-03 04:06:58 +00001565 NamedDecl *D = *I;
1566 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
1567 if (isa<UsingShadowDecl>(D))
1568 D = cast<UsingShadowDecl>(D)->getTargetDecl();
1569
Fariborz Jahanianf9012a32009-09-11 18:46:22 +00001570 CXXConversionDecl *Conv;
1571 FunctionTemplateDecl *ConvTemplate;
John McCalld14a8642009-11-21 08:51:07 +00001572 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(*I)))
Fariborz Jahanianf9012a32009-09-11 18:46:22 +00001573 Conv = dyn_cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
1574 else
John McCalld14a8642009-11-21 08:51:07 +00001575 Conv = dyn_cast<CXXConversionDecl>(*I);
Fariborz Jahanianf9012a32009-09-11 18:46:22 +00001576
1577 if (AllowExplicit || !Conv->isExplicit()) {
1578 if (ConvTemplate)
John McCallb89836b2010-01-26 01:37:31 +00001579 AddTemplateConversionCandidate(ConvTemplate, I.getAccess(),
1580 ActingContext, From, ToType,
1581 CandidateSet);
Fariborz Jahanianf9012a32009-09-11 18:46:22 +00001582 else
John McCallb89836b2010-01-26 01:37:31 +00001583 AddConversionCandidate(Conv, I.getAccess(), ActingContext,
1584 From, ToType, CandidateSet);
Fariborz Jahanianf9012a32009-09-11 18:46:22 +00001585 }
1586 }
1587 }
Douglas Gregora1f013e2008-11-07 22:36:19 +00001588 }
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001589
1590 OverloadCandidateSet::iterator Best;
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00001591 switch (BestViableFunction(CandidateSet, From->getLocStart(), Best)) {
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001592 case OR_Success:
1593 // Record the standard conversion we used and the conversion function.
Mike Stump11289f42009-09-09 15:08:12 +00001594 if (CXXConstructorDecl *Constructor
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001595 = dyn_cast<CXXConstructorDecl>(Best->Function)) {
1596 // C++ [over.ics.user]p1:
1597 // If the user-defined conversion is specified by a
1598 // constructor (12.3.1), the initial standard conversion
1599 // sequence converts the source type to the type required by
1600 // the argument of the constructor.
1601 //
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001602 QualType ThisType = Constructor->getThisType(Context);
John McCall0d1da222010-01-12 00:44:57 +00001603 if (Best->Conversions[0].isEllipsis())
Fariborz Jahanian55824512009-11-06 00:23:08 +00001604 User.EllipsisConversion = true;
1605 else {
1606 User.Before = Best->Conversions[0].Standard;
1607 User.EllipsisConversion = false;
1608 }
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001609 User.ConversionFunction = Constructor;
1610 User.After.setAsIdentityConversion();
John McCall0d1da222010-01-12 00:44:57 +00001611 User.After.setFromType(
1612 ThisType->getAs<PointerType>()->getPointeeType());
Douglas Gregor3edc4d52010-01-27 03:51:04 +00001613 User.After.setAllToTypes(ToType);
Fariborz Jahanian3e6b57e2009-09-15 19:12:21 +00001614 return OR_Success;
Douglas Gregora1f013e2008-11-07 22:36:19 +00001615 } else if (CXXConversionDecl *Conversion
1616 = dyn_cast<CXXConversionDecl>(Best->Function)) {
1617 // C++ [over.ics.user]p1:
1618 //
1619 // [...] If the user-defined conversion is specified by a
1620 // conversion function (12.3.2), the initial standard
1621 // conversion sequence converts the source type to the
1622 // implicit object parameter of the conversion function.
1623 User.Before = Best->Conversions[0].Standard;
1624 User.ConversionFunction = Conversion;
Fariborz Jahanian55824512009-11-06 00:23:08 +00001625 User.EllipsisConversion = false;
Mike Stump11289f42009-09-09 15:08:12 +00001626
1627 // C++ [over.ics.user]p2:
Douglas Gregora1f013e2008-11-07 22:36:19 +00001628 // The second standard conversion sequence converts the
1629 // result of the user-defined conversion to the target type
1630 // for the sequence. Since an implicit conversion sequence
1631 // is an initialization, the special rules for
1632 // initialization by user-defined conversion apply when
1633 // selecting the best user-defined conversion for a
1634 // user-defined conversion sequence (see 13.3.3 and
1635 // 13.3.3.1).
1636 User.After = Best->FinalConversion;
Fariborz Jahanian3e6b57e2009-09-15 19:12:21 +00001637 return OR_Success;
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001638 } else {
Douglas Gregora1f013e2008-11-07 22:36:19 +00001639 assert(false && "Not a constructor or conversion function?");
Fariborz Jahanian3e6b57e2009-09-15 19:12:21 +00001640 return OR_No_Viable_Function;
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001641 }
Mike Stump11289f42009-09-09 15:08:12 +00001642
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001643 case OR_No_Viable_Function:
Fariborz Jahanian3e6b57e2009-09-15 19:12:21 +00001644 return OR_No_Viable_Function;
Douglas Gregor171c45a2009-02-18 21:56:37 +00001645 case OR_Deleted:
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001646 // No conversion here! We're done.
Fariborz Jahanian3e6b57e2009-09-15 19:12:21 +00001647 return OR_Deleted;
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001648
1649 case OR_Ambiguous:
Fariborz Jahanian3e6b57e2009-09-15 19:12:21 +00001650 return OR_Ambiguous;
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001651 }
1652
Fariborz Jahanian3e6b57e2009-09-15 19:12:21 +00001653 return OR_No_Viable_Function;
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001654}
Fariborz Jahanianf0647a52009-09-22 20:24:30 +00001655
1656bool
Fariborz Jahanian76197412009-11-18 18:26:29 +00001657Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
Fariborz Jahanianf0647a52009-09-22 20:24:30 +00001658 ImplicitConversionSequence ICS;
John McCallbc077cf2010-02-08 23:07:23 +00001659 OverloadCandidateSet CandidateSet(From->getExprLoc());
Fariborz Jahanianf0647a52009-09-22 20:24:30 +00001660 OverloadingResult OvResult =
1661 IsUserDefinedConversion(From, ToType, ICS.UserDefined,
1662 CandidateSet, true, false, false);
Fariborz Jahanian76197412009-11-18 18:26:29 +00001663 if (OvResult == OR_Ambiguous)
1664 Diag(From->getSourceRange().getBegin(),
1665 diag::err_typecheck_ambiguous_condition)
1666 << From->getType() << ToType << From->getSourceRange();
1667 else if (OvResult == OR_No_Viable_Function && !CandidateSet.empty())
1668 Diag(From->getSourceRange().getBegin(),
1669 diag::err_typecheck_nonviable_condition)
1670 << From->getType() << ToType << From->getSourceRange();
1671 else
Fariborz Jahanianf0647a52009-09-22 20:24:30 +00001672 return false;
John McCallad907772010-01-12 07:18:19 +00001673 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, &From, 1);
Fariborz Jahanianf0647a52009-09-22 20:24:30 +00001674 return true;
1675}
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001676
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001677/// CompareImplicitConversionSequences - Compare two implicit
1678/// conversion sequences to determine whether one is better than the
1679/// other or if they are indistinguishable (C++ 13.3.3.2).
Mike Stump11289f42009-09-09 15:08:12 +00001680ImplicitConversionSequence::CompareKind
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001681Sema::CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
1682 const ImplicitConversionSequence& ICS2)
1683{
1684 // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
1685 // conversion sequences (as defined in 13.3.3.1)
1686 // -- a standard conversion sequence (13.3.3.1.1) is a better
1687 // conversion sequence than a user-defined conversion sequence or
1688 // an ellipsis conversion sequence, and
1689 // -- a user-defined conversion sequence (13.3.3.1.2) is a better
1690 // conversion sequence than an ellipsis conversion sequence
1691 // (13.3.3.1.3).
Mike Stump11289f42009-09-09 15:08:12 +00001692 //
John McCall0d1da222010-01-12 00:44:57 +00001693 // C++0x [over.best.ics]p10:
1694 // For the purpose of ranking implicit conversion sequences as
1695 // described in 13.3.3.2, the ambiguous conversion sequence is
1696 // treated as a user-defined sequence that is indistinguishable
1697 // from any other user-defined conversion sequence.
1698 if (ICS1.getKind() < ICS2.getKind()) {
1699 if (!(ICS1.isUserDefined() && ICS2.isAmbiguous()))
1700 return ImplicitConversionSequence::Better;
1701 } else if (ICS2.getKind() < ICS1.getKind()) {
1702 if (!(ICS2.isUserDefined() && ICS1.isAmbiguous()))
1703 return ImplicitConversionSequence::Worse;
1704 }
1705
1706 if (ICS1.isAmbiguous() || ICS2.isAmbiguous())
1707 return ImplicitConversionSequence::Indistinguishable;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001708
1709 // Two implicit conversion sequences of the same form are
1710 // indistinguishable conversion sequences unless one of the
1711 // following rules apply: (C++ 13.3.3.2p3):
John McCall0d1da222010-01-12 00:44:57 +00001712 if (ICS1.isStandard())
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001713 return CompareStandardConversionSequences(ICS1.Standard, ICS2.Standard);
John McCall0d1da222010-01-12 00:44:57 +00001714 else if (ICS1.isUserDefined()) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001715 // User-defined conversion sequence U1 is a better conversion
1716 // sequence than another user-defined conversion sequence U2 if
1717 // they contain the same user-defined conversion function or
1718 // constructor and if the second standard conversion sequence of
1719 // U1 is better than the second standard conversion sequence of
1720 // U2 (C++ 13.3.3.2p3).
Mike Stump11289f42009-09-09 15:08:12 +00001721 if (ICS1.UserDefined.ConversionFunction ==
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001722 ICS2.UserDefined.ConversionFunction)
1723 return CompareStandardConversionSequences(ICS1.UserDefined.After,
1724 ICS2.UserDefined.After);
1725 }
1726
1727 return ImplicitConversionSequence::Indistinguishable;
1728}
1729
Douglas Gregor3edc4d52010-01-27 03:51:04 +00001730// Per 13.3.3.2p3, compare the given standard conversion sequences to
1731// determine if one is a proper subset of the other.
1732static ImplicitConversionSequence::CompareKind
1733compareStandardConversionSubsets(ASTContext &Context,
1734 const StandardConversionSequence& SCS1,
1735 const StandardConversionSequence& SCS2) {
1736 ImplicitConversionSequence::CompareKind Result
1737 = ImplicitConversionSequence::Indistinguishable;
1738
1739 if (SCS1.Second != SCS2.Second) {
1740 if (SCS1.Second == ICK_Identity)
1741 Result = ImplicitConversionSequence::Better;
1742 else if (SCS2.Second == ICK_Identity)
1743 Result = ImplicitConversionSequence::Worse;
1744 else
1745 return ImplicitConversionSequence::Indistinguishable;
1746 } else if (!Context.hasSameType(SCS1.getToType(1), SCS2.getToType(1)))
1747 return ImplicitConversionSequence::Indistinguishable;
1748
1749 if (SCS1.Third == SCS2.Third) {
1750 return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result
1751 : ImplicitConversionSequence::Indistinguishable;
1752 }
1753
1754 if (SCS1.Third == ICK_Identity)
1755 return Result == ImplicitConversionSequence::Worse
1756 ? ImplicitConversionSequence::Indistinguishable
1757 : ImplicitConversionSequence::Better;
1758
1759 if (SCS2.Third == ICK_Identity)
1760 return Result == ImplicitConversionSequence::Better
1761 ? ImplicitConversionSequence::Indistinguishable
1762 : ImplicitConversionSequence::Worse;
1763
1764 return ImplicitConversionSequence::Indistinguishable;
1765}
1766
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001767/// CompareStandardConversionSequences - Compare two standard
1768/// conversion sequences to determine whether one is better than the
1769/// other or if they are indistinguishable (C++ 13.3.3.2p3).
Mike Stump11289f42009-09-09 15:08:12 +00001770ImplicitConversionSequence::CompareKind
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001771Sema::CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
1772 const StandardConversionSequence& SCS2)
1773{
1774 // Standard conversion sequence S1 is a better conversion sequence
1775 // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
1776
1777 // -- S1 is a proper subsequence of S2 (comparing the conversion
1778 // sequences in the canonical form defined by 13.3.3.1.1,
1779 // excluding any Lvalue Transformation; the identity conversion
1780 // sequence is considered to be a subsequence of any
1781 // non-identity conversion sequence) or, if not that,
Douglas Gregor3edc4d52010-01-27 03:51:04 +00001782 if (ImplicitConversionSequence::CompareKind CK
1783 = compareStandardConversionSubsets(Context, SCS1, SCS2))
1784 return CK;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001785
1786 // -- the rank of S1 is better than the rank of S2 (by the rules
1787 // defined below), or, if not that,
1788 ImplicitConversionRank Rank1 = SCS1.getRank();
1789 ImplicitConversionRank Rank2 = SCS2.getRank();
1790 if (Rank1 < Rank2)
1791 return ImplicitConversionSequence::Better;
1792 else if (Rank2 < Rank1)
1793 return ImplicitConversionSequence::Worse;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001794
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001795 // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
1796 // are indistinguishable unless one of the following rules
1797 // applies:
Mike Stump11289f42009-09-09 15:08:12 +00001798
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001799 // A conversion that is not a conversion of a pointer, or
1800 // pointer to member, to bool is better than another conversion
1801 // that is such a conversion.
1802 if (SCS1.isPointerConversionToBool() != SCS2.isPointerConversionToBool())
1803 return SCS2.isPointerConversionToBool()
1804 ? ImplicitConversionSequence::Better
1805 : ImplicitConversionSequence::Worse;
1806
Douglas Gregor5c407d92008-10-23 00:40:37 +00001807 // C++ [over.ics.rank]p4b2:
1808 //
1809 // If class B is derived directly or indirectly from class A,
Douglas Gregoref30a5f2008-10-29 14:50:44 +00001810 // conversion of B* to A* is better than conversion of B* to
1811 // void*, and conversion of A* to void* is better than conversion
1812 // of B* to void*.
Mike Stump11289f42009-09-09 15:08:12 +00001813 bool SCS1ConvertsToVoid
Douglas Gregor5c407d92008-10-23 00:40:37 +00001814 = SCS1.isPointerConversionToVoidPointer(Context);
Mike Stump11289f42009-09-09 15:08:12 +00001815 bool SCS2ConvertsToVoid
Douglas Gregor5c407d92008-10-23 00:40:37 +00001816 = SCS2.isPointerConversionToVoidPointer(Context);
Douglas Gregoref30a5f2008-10-29 14:50:44 +00001817 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
1818 // Exactly one of the conversion sequences is a conversion to
1819 // a void pointer; it's the worse conversion.
Douglas Gregor5c407d92008-10-23 00:40:37 +00001820 return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better
1821 : ImplicitConversionSequence::Worse;
Douglas Gregoref30a5f2008-10-29 14:50:44 +00001822 } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
1823 // Neither conversion sequence converts to a void pointer; compare
1824 // their derived-to-base conversions.
Douglas Gregor5c407d92008-10-23 00:40:37 +00001825 if (ImplicitConversionSequence::CompareKind DerivedCK
1826 = CompareDerivedToBaseConversions(SCS1, SCS2))
1827 return DerivedCK;
Douglas Gregoref30a5f2008-10-29 14:50:44 +00001828 } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid) {
1829 // Both conversion sequences are conversions to void
1830 // pointers. Compare the source types to determine if there's an
1831 // inheritance relationship in their sources.
John McCall0d1da222010-01-12 00:44:57 +00001832 QualType FromType1 = SCS1.getFromType();
1833 QualType FromType2 = SCS2.getFromType();
Douglas Gregoref30a5f2008-10-29 14:50:44 +00001834
1835 // Adjust the types we're converting from via the array-to-pointer
1836 // conversion, if we need to.
1837 if (SCS1.First == ICK_Array_To_Pointer)
1838 FromType1 = Context.getArrayDecayedType(FromType1);
1839 if (SCS2.First == ICK_Array_To_Pointer)
1840 FromType2 = Context.getArrayDecayedType(FromType2);
1841
Douglas Gregor1aa450a2009-12-13 21:37:05 +00001842 QualType FromPointee1
1843 = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
1844 QualType FromPointee2
1845 = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
Douglas Gregoref30a5f2008-10-29 14:50:44 +00001846
Douglas Gregor1aa450a2009-12-13 21:37:05 +00001847 if (IsDerivedFrom(FromPointee2, FromPointee1))
1848 return ImplicitConversionSequence::Better;
1849 else if (IsDerivedFrom(FromPointee1, FromPointee2))
1850 return ImplicitConversionSequence::Worse;
1851
1852 // Objective-C++: If one interface is more specific than the
1853 // other, it is the better one.
1854 const ObjCInterfaceType* FromIface1 = FromPointee1->getAs<ObjCInterfaceType>();
1855 const ObjCInterfaceType* FromIface2 = FromPointee2->getAs<ObjCInterfaceType>();
1856 if (FromIface1 && FromIface1) {
1857 if (Context.canAssignObjCInterfaces(FromIface2, FromIface1))
1858 return ImplicitConversionSequence::Better;
1859 else if (Context.canAssignObjCInterfaces(FromIface1, FromIface2))
1860 return ImplicitConversionSequence::Worse;
1861 }
Douglas Gregoref30a5f2008-10-29 14:50:44 +00001862 }
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001863
1864 // Compare based on qualification conversions (C++ 13.3.3.2p3,
1865 // bullet 3).
Mike Stump11289f42009-09-09 15:08:12 +00001866 if (ImplicitConversionSequence::CompareKind QualCK
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001867 = CompareQualificationConversions(SCS1, SCS2))
Douglas Gregor5c407d92008-10-23 00:40:37 +00001868 return QualCK;
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001869
Douglas Gregoref30a5f2008-10-29 14:50:44 +00001870 if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
Sebastian Redlb28b4072009-03-22 23:49:27 +00001871 // C++0x [over.ics.rank]p3b4:
1872 // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an
1873 // implicit object parameter of a non-static member function declared
1874 // without a ref-qualifier, and S1 binds an rvalue reference to an
1875 // rvalue and S2 binds an lvalue reference.
Sebastian Redl4c0cd852009-03-29 15:27:50 +00001876 // FIXME: We don't know if we're dealing with the implicit object parameter,
1877 // or if the member function in this case has a ref qualifier.
1878 // (Of course, we don't have ref qualifiers yet.)
1879 if (SCS1.RRefBinding != SCS2.RRefBinding)
1880 return SCS1.RRefBinding ? ImplicitConversionSequence::Better
1881 : ImplicitConversionSequence::Worse;
Sebastian Redlb28b4072009-03-22 23:49:27 +00001882
1883 // C++ [over.ics.rank]p3b4:
1884 // -- S1 and S2 are reference bindings (8.5.3), and the types to
1885 // which the references refer are the same type except for
1886 // top-level cv-qualifiers, and the type to which the reference
1887 // initialized by S2 refers is more cv-qualified than the type
1888 // to which the reference initialized by S1 refers.
Douglas Gregor3edc4d52010-01-27 03:51:04 +00001889 QualType T1 = SCS1.getToType(2);
1890 QualType T2 = SCS2.getToType(2);
Douglas Gregoref30a5f2008-10-29 14:50:44 +00001891 T1 = Context.getCanonicalType(T1);
1892 T2 = Context.getCanonicalType(T2);
Chandler Carruth607f38e2009-12-29 07:16:59 +00001893 Qualifiers T1Quals, T2Quals;
1894 QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
1895 QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
1896 if (UnqualT1 == UnqualT2) {
1897 // If the type is an array type, promote the element qualifiers to the type
1898 // for comparison.
1899 if (isa<ArrayType>(T1) && T1Quals)
1900 T1 = Context.getQualifiedType(UnqualT1, T1Quals);
1901 if (isa<ArrayType>(T2) && T2Quals)
1902 T2 = Context.getQualifiedType(UnqualT2, T2Quals);
Douglas Gregoref30a5f2008-10-29 14:50:44 +00001903 if (T2.isMoreQualifiedThan(T1))
1904 return ImplicitConversionSequence::Better;
1905 else if (T1.isMoreQualifiedThan(T2))
1906 return ImplicitConversionSequence::Worse;
1907 }
1908 }
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001909
1910 return ImplicitConversionSequence::Indistinguishable;
1911}
1912
1913/// CompareQualificationConversions - Compares two standard conversion
1914/// sequences to determine whether they can be ranked based on their
Mike Stump11289f42009-09-09 15:08:12 +00001915/// qualification conversions (C++ 13.3.3.2p3 bullet 3).
1916ImplicitConversionSequence::CompareKind
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001917Sema::CompareQualificationConversions(const StandardConversionSequence& SCS1,
Mike Stump11289f42009-09-09 15:08:12 +00001918 const StandardConversionSequence& SCS2) {
Douglas Gregor4b62ec62008-10-22 15:04:37 +00001919 // C++ 13.3.3.2p3:
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001920 // -- S1 and S2 differ only in their qualification conversion and
1921 // yield similar types T1 and T2 (C++ 4.4), respectively, and the
1922 // cv-qualification signature of type T1 is a proper subset of
1923 // the cv-qualification signature of type T2, and S1 is not the
1924 // deprecated string literal array-to-pointer conversion (4.2).
1925 if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second ||
1926 SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification)
1927 return ImplicitConversionSequence::Indistinguishable;
1928
1929 // FIXME: the example in the standard doesn't use a qualification
1930 // conversion (!)
Douglas Gregor3edc4d52010-01-27 03:51:04 +00001931 QualType T1 = SCS1.getToType(2);
1932 QualType T2 = SCS2.getToType(2);
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001933 T1 = Context.getCanonicalType(T1);
1934 T2 = Context.getCanonicalType(T2);
Chandler Carruth607f38e2009-12-29 07:16:59 +00001935 Qualifiers T1Quals, T2Quals;
1936 QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
1937 QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001938
1939 // If the types are the same, we won't learn anything by unwrapped
1940 // them.
Chandler Carruth607f38e2009-12-29 07:16:59 +00001941 if (UnqualT1 == UnqualT2)
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001942 return ImplicitConversionSequence::Indistinguishable;
1943
Chandler Carruth607f38e2009-12-29 07:16:59 +00001944 // If the type is an array type, promote the element qualifiers to the type
1945 // for comparison.
1946 if (isa<ArrayType>(T1) && T1Quals)
1947 T1 = Context.getQualifiedType(UnqualT1, T1Quals);
1948 if (isa<ArrayType>(T2) && T2Quals)
1949 T2 = Context.getQualifiedType(UnqualT2, T2Quals);
1950
Mike Stump11289f42009-09-09 15:08:12 +00001951 ImplicitConversionSequence::CompareKind Result
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001952 = ImplicitConversionSequence::Indistinguishable;
1953 while (UnwrapSimilarPointerTypes(T1, T2)) {
1954 // Within each iteration of the loop, we check the qualifiers to
1955 // determine if this still looks like a qualification
1956 // conversion. Then, if all is well, we unwrap one more level of
Douglas Gregor29a92472008-10-22 17:49:05 +00001957 // pointers or pointers-to-members and do it all again
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001958 // until there are no more pointers or pointers-to-members left
1959 // to unwrap. This essentially mimics what
1960 // IsQualificationConversion does, but here we're checking for a
1961 // strict subset of qualifiers.
1962 if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
1963 // The qualifiers are the same, so this doesn't tell us anything
1964 // about how the sequences rank.
1965 ;
1966 else if (T2.isMoreQualifiedThan(T1)) {
1967 // T1 has fewer qualifiers, so it could be the better sequence.
1968 if (Result == ImplicitConversionSequence::Worse)
1969 // Neither has qualifiers that are a subset of the other's
1970 // qualifiers.
1971 return ImplicitConversionSequence::Indistinguishable;
Mike Stump11289f42009-09-09 15:08:12 +00001972
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001973 Result = ImplicitConversionSequence::Better;
1974 } else if (T1.isMoreQualifiedThan(T2)) {
1975 // T2 has fewer qualifiers, so it could be the better sequence.
1976 if (Result == ImplicitConversionSequence::Better)
1977 // Neither has qualifiers that are a subset of the other's
1978 // qualifiers.
1979 return ImplicitConversionSequence::Indistinguishable;
Mike Stump11289f42009-09-09 15:08:12 +00001980
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001981 Result = ImplicitConversionSequence::Worse;
1982 } else {
1983 // Qualifiers are disjoint.
1984 return ImplicitConversionSequence::Indistinguishable;
1985 }
1986
1987 // If the types after this point are equivalent, we're done.
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00001988 if (Context.hasSameUnqualifiedType(T1, T2))
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001989 break;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001990 }
1991
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001992 // Check that the winning standard conversion sequence isn't using
1993 // the deprecated string literal array to pointer conversion.
1994 switch (Result) {
1995 case ImplicitConversionSequence::Better:
Douglas Gregore489a7d2010-02-28 18:30:25 +00001996 if (SCS1.DeprecatedStringLiteralToCharPtr)
Douglas Gregore1eb9d82008-10-22 14:17:15 +00001997 Result = ImplicitConversionSequence::Indistinguishable;
1998 break;
1999
2000 case ImplicitConversionSequence::Indistinguishable:
2001 break;
2002
2003 case ImplicitConversionSequence::Worse:
Douglas Gregore489a7d2010-02-28 18:30:25 +00002004 if (SCS2.DeprecatedStringLiteralToCharPtr)
Douglas Gregore1eb9d82008-10-22 14:17:15 +00002005 Result = ImplicitConversionSequence::Indistinguishable;
2006 break;
2007 }
2008
2009 return Result;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002010}
2011
Douglas Gregor5c407d92008-10-23 00:40:37 +00002012/// CompareDerivedToBaseConversions - Compares two standard conversion
2013/// sequences to determine whether they can be ranked based on their
Douglas Gregor237f96c2008-11-26 23:31:11 +00002014/// various kinds of derived-to-base conversions (C++
2015/// [over.ics.rank]p4b3). As part of these checks, we also look at
2016/// conversions between Objective-C interface types.
Douglas Gregor5c407d92008-10-23 00:40:37 +00002017ImplicitConversionSequence::CompareKind
2018Sema::CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1,
2019 const StandardConversionSequence& SCS2) {
John McCall0d1da222010-01-12 00:44:57 +00002020 QualType FromType1 = SCS1.getFromType();
Douglas Gregor3edc4d52010-01-27 03:51:04 +00002021 QualType ToType1 = SCS1.getToType(1);
John McCall0d1da222010-01-12 00:44:57 +00002022 QualType FromType2 = SCS2.getFromType();
Douglas Gregor3edc4d52010-01-27 03:51:04 +00002023 QualType ToType2 = SCS2.getToType(1);
Douglas Gregor5c407d92008-10-23 00:40:37 +00002024
2025 // Adjust the types we're converting from via the array-to-pointer
2026 // conversion, if we need to.
2027 if (SCS1.First == ICK_Array_To_Pointer)
2028 FromType1 = Context.getArrayDecayedType(FromType1);
2029 if (SCS2.First == ICK_Array_To_Pointer)
2030 FromType2 = Context.getArrayDecayedType(FromType2);
2031
2032 // Canonicalize all of the types.
2033 FromType1 = Context.getCanonicalType(FromType1);
2034 ToType1 = Context.getCanonicalType(ToType1);
2035 FromType2 = Context.getCanonicalType(FromType2);
2036 ToType2 = Context.getCanonicalType(ToType2);
2037
Douglas Gregoref30a5f2008-10-29 14:50:44 +00002038 // C++ [over.ics.rank]p4b3:
Douglas Gregor5c407d92008-10-23 00:40:37 +00002039 //
2040 // If class B is derived directly or indirectly from class A and
2041 // class C is derived directly or indirectly from B,
Douglas Gregor237f96c2008-11-26 23:31:11 +00002042 //
2043 // For Objective-C, we let A, B, and C also be Objective-C
2044 // interfaces.
Douglas Gregoref30a5f2008-10-29 14:50:44 +00002045
2046 // Compare based on pointer conversions.
Mike Stump11289f42009-09-09 15:08:12 +00002047 if (SCS1.Second == ICK_Pointer_Conversion &&
Douglas Gregora29dc052008-11-27 01:19:21 +00002048 SCS2.Second == ICK_Pointer_Conversion &&
2049 /*FIXME: Remove if Objective-C id conversions get their own rank*/
2050 FromType1->isPointerType() && FromType2->isPointerType() &&
2051 ToType1->isPointerType() && ToType2->isPointerType()) {
Mike Stump11289f42009-09-09 15:08:12 +00002052 QualType FromPointee1
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002053 = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
Mike Stump11289f42009-09-09 15:08:12 +00002054 QualType ToPointee1
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002055 = ToType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
Douglas Gregor5c407d92008-10-23 00:40:37 +00002056 QualType FromPointee2
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002057 = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
Douglas Gregor5c407d92008-10-23 00:40:37 +00002058 QualType ToPointee2
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002059 = ToType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
Douglas Gregor237f96c2008-11-26 23:31:11 +00002060
John McCall9dd450b2009-09-21 23:43:11 +00002061 const ObjCInterfaceType* FromIface1 = FromPointee1->getAs<ObjCInterfaceType>();
2062 const ObjCInterfaceType* FromIface2 = FromPointee2->getAs<ObjCInterfaceType>();
2063 const ObjCInterfaceType* ToIface1 = ToPointee1->getAs<ObjCInterfaceType>();
2064 const ObjCInterfaceType* ToIface2 = ToPointee2->getAs<ObjCInterfaceType>();
Douglas Gregor237f96c2008-11-26 23:31:11 +00002065
Douglas Gregoref30a5f2008-10-29 14:50:44 +00002066 // -- conversion of C* to B* is better than conversion of C* to A*,
Douglas Gregor5c407d92008-10-23 00:40:37 +00002067 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
2068 if (IsDerivedFrom(ToPointee1, ToPointee2))
2069 return ImplicitConversionSequence::Better;
2070 else if (IsDerivedFrom(ToPointee2, ToPointee1))
2071 return ImplicitConversionSequence::Worse;
Douglas Gregor237f96c2008-11-26 23:31:11 +00002072
2073 if (ToIface1 && ToIface2) {
2074 if (Context.canAssignObjCInterfaces(ToIface2, ToIface1))
2075 return ImplicitConversionSequence::Better;
2076 else if (Context.canAssignObjCInterfaces(ToIface1, ToIface2))
2077 return ImplicitConversionSequence::Worse;
2078 }
Douglas Gregor5c407d92008-10-23 00:40:37 +00002079 }
Douglas Gregoref30a5f2008-10-29 14:50:44 +00002080
2081 // -- conversion of B* to A* is better than conversion of C* to A*,
2082 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
2083 if (IsDerivedFrom(FromPointee2, FromPointee1))
2084 return ImplicitConversionSequence::Better;
2085 else if (IsDerivedFrom(FromPointee1, FromPointee2))
2086 return ImplicitConversionSequence::Worse;
Mike Stump11289f42009-09-09 15:08:12 +00002087
Douglas Gregor237f96c2008-11-26 23:31:11 +00002088 if (FromIface1 && FromIface2) {
2089 if (Context.canAssignObjCInterfaces(FromIface1, FromIface2))
2090 return ImplicitConversionSequence::Better;
2091 else if (Context.canAssignObjCInterfaces(FromIface2, FromIface1))
2092 return ImplicitConversionSequence::Worse;
2093 }
Douglas Gregoref30a5f2008-10-29 14:50:44 +00002094 }
Douglas Gregor5c407d92008-10-23 00:40:37 +00002095 }
2096
Fariborz Jahanianac741ff2009-10-20 20:07:35 +00002097 // Ranking of member-pointer types.
Fariborz Jahanian9a587b02009-10-20 20:04:46 +00002098 if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member &&
2099 FromType1->isMemberPointerType() && FromType2->isMemberPointerType() &&
2100 ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) {
2101 const MemberPointerType * FromMemPointer1 =
2102 FromType1->getAs<MemberPointerType>();
2103 const MemberPointerType * ToMemPointer1 =
2104 ToType1->getAs<MemberPointerType>();
2105 const MemberPointerType * FromMemPointer2 =
2106 FromType2->getAs<MemberPointerType>();
2107 const MemberPointerType * ToMemPointer2 =
2108 ToType2->getAs<MemberPointerType>();
2109 const Type *FromPointeeType1 = FromMemPointer1->getClass();
2110 const Type *ToPointeeType1 = ToMemPointer1->getClass();
2111 const Type *FromPointeeType2 = FromMemPointer2->getClass();
2112 const Type *ToPointeeType2 = ToMemPointer2->getClass();
2113 QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType();
2114 QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType();
2115 QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType();
2116 QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType();
Fariborz Jahanianac741ff2009-10-20 20:07:35 +00002117 // conversion of A::* to B::* is better than conversion of A::* to C::*,
Fariborz Jahanian9a587b02009-10-20 20:04:46 +00002118 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
2119 if (IsDerivedFrom(ToPointee1, ToPointee2))
2120 return ImplicitConversionSequence::Worse;
2121 else if (IsDerivedFrom(ToPointee2, ToPointee1))
2122 return ImplicitConversionSequence::Better;
2123 }
2124 // conversion of B::* to C::* is better than conversion of A::* to C::*
2125 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
2126 if (IsDerivedFrom(FromPointee1, FromPointee2))
2127 return ImplicitConversionSequence::Better;
2128 else if (IsDerivedFrom(FromPointee2, FromPointee1))
2129 return ImplicitConversionSequence::Worse;
2130 }
2131 }
2132
Douglas Gregor83af86a2010-02-25 19:01:05 +00002133 if ((SCS1.ReferenceBinding || SCS1.CopyConstructor) &&
2134 (SCS2.ReferenceBinding || SCS2.CopyConstructor) &&
Douglas Gregor2fe98832008-11-03 19:09:14 +00002135 SCS1.Second == ICK_Derived_To_Base) {
2136 // -- conversion of C to B is better than conversion of C to A,
Douglas Gregor83af86a2010-02-25 19:01:05 +00002137 // -- binding of an expression of type C to a reference of type
2138 // B& is better than binding an expression of type C to a
2139 // reference of type A&,
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00002140 if (Context.hasSameUnqualifiedType(FromType1, FromType2) &&
2141 !Context.hasSameUnqualifiedType(ToType1, ToType2)) {
Douglas Gregor2fe98832008-11-03 19:09:14 +00002142 if (IsDerivedFrom(ToType1, ToType2))
2143 return ImplicitConversionSequence::Better;
2144 else if (IsDerivedFrom(ToType2, ToType1))
2145 return ImplicitConversionSequence::Worse;
2146 }
Douglas Gregoref30a5f2008-10-29 14:50:44 +00002147
Douglas Gregor2fe98832008-11-03 19:09:14 +00002148 // -- conversion of B to A is better than conversion of C to A.
Douglas Gregor83af86a2010-02-25 19:01:05 +00002149 // -- binding of an expression of type B to a reference of type
2150 // A& is better than binding an expression of type C to a
2151 // reference of type A&,
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00002152 if (!Context.hasSameUnqualifiedType(FromType1, FromType2) &&
2153 Context.hasSameUnqualifiedType(ToType1, ToType2)) {
Douglas Gregor2fe98832008-11-03 19:09:14 +00002154 if (IsDerivedFrom(FromType2, FromType1))
2155 return ImplicitConversionSequence::Better;
2156 else if (IsDerivedFrom(FromType1, FromType2))
2157 return ImplicitConversionSequence::Worse;
2158 }
2159 }
Douglas Gregoref30a5f2008-10-29 14:50:44 +00002160
Douglas Gregor5c407d92008-10-23 00:40:37 +00002161 return ImplicitConversionSequence::Indistinguishable;
2162}
2163
Douglas Gregor8e1cf602008-10-29 00:13:59 +00002164/// TryCopyInitialization - Try to copy-initialize a value of type
2165/// ToType from the expression From. Return the implicit conversion
2166/// sequence required to pass this argument, which may be a bad
2167/// conversion sequence (meaning that the argument cannot be passed to
Douglas Gregor2fe98832008-11-03 19:09:14 +00002168/// a parameter of this type). If @p SuppressUserConversions, then we
Sebastian Redl42e92c42009-04-12 17:16:29 +00002169/// do not permit any user-defined conversion sequences. If @p ForceRValue,
2170/// then we treat @p From as an rvalue, even if it is an lvalue.
Mike Stump11289f42009-09-09 15:08:12 +00002171ImplicitConversionSequence
2172Sema::TryCopyInitialization(Expr *From, QualType ToType,
Anders Carlsson20d13322009-08-27 17:37:39 +00002173 bool SuppressUserConversions, bool ForceRValue,
2174 bool InOverloadResolution) {
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00002175 if (ToType->isReferenceType()) {
Douglas Gregor8e1cf602008-10-29 00:13:59 +00002176 ImplicitConversionSequence ICS;
John McCall65eb8792010-02-25 01:37:24 +00002177 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
Mike Stump11289f42009-09-09 15:08:12 +00002178 CheckReferenceInit(From, ToType,
Douglas Gregorc809cc22009-09-23 23:04:10 +00002179 /*FIXME:*/From->getLocStart(),
Anders Carlsson271e3a42009-08-27 17:30:43 +00002180 SuppressUserConversions,
2181 /*AllowExplicit=*/false,
2182 ForceRValue,
2183 &ICS);
Douglas Gregor8e1cf602008-10-29 00:13:59 +00002184 return ICS;
2185 } else {
Mike Stump11289f42009-09-09 15:08:12 +00002186 return TryImplicitConversion(From, ToType,
Anders Carlssonef4c7212009-08-27 17:24:15 +00002187 SuppressUserConversions,
2188 /*AllowExplicit=*/false,
Anders Carlsson228eea32009-08-28 15:33:32 +00002189 ForceRValue,
2190 InOverloadResolution);
Douglas Gregor8e1cf602008-10-29 00:13:59 +00002191 }
2192}
2193
Sebastian Redl42e92c42009-04-12 17:16:29 +00002194/// PerformCopyInitialization - Copy-initialize an object of type @p ToType with
2195/// the expression @p From. Returns true (and emits a diagnostic) if there was
2196/// an error, returns false if the initialization succeeded. Elidable should
2197/// be true when the copy may be elided (C++ 12.8p15). Overload resolution works
2198/// differently in C++0x for this case.
Mike Stump11289f42009-09-09 15:08:12 +00002199bool Sema::PerformCopyInitialization(Expr *&From, QualType ToType,
Douglas Gregor7c3bbdf2009-12-16 03:45:30 +00002200 AssignmentAction Action, bool Elidable) {
Douglas Gregor8e1cf602008-10-29 00:13:59 +00002201 if (!getLangOptions().CPlusPlus) {
2202 // In C, argument passing is the same as performing an assignment.
2203 QualType FromType = From->getType();
Mike Stump11289f42009-09-09 15:08:12 +00002204
Douglas Gregor8e1cf602008-10-29 00:13:59 +00002205 AssignConvertType ConvTy =
2206 CheckSingleAssignmentConstraints(ToType, From);
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00002207 if (ConvTy != Compatible &&
2208 CheckTransparentUnionArgumentConstraints(ToType, From) == Compatible)
2209 ConvTy = Compatible;
Mike Stump11289f42009-09-09 15:08:12 +00002210
Douglas Gregor8e1cf602008-10-29 00:13:59 +00002211 return DiagnoseAssignmentResult(ConvTy, From->getLocStart(), ToType,
Douglas Gregor7c3bbdf2009-12-16 03:45:30 +00002212 FromType, From, Action);
Douglas Gregor8e1cf602008-10-29 00:13:59 +00002213 }
Sebastian Redl42e92c42009-04-12 17:16:29 +00002214
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00002215 if (ToType->isReferenceType())
Anders Carlsson271e3a42009-08-27 17:30:43 +00002216 return CheckReferenceInit(From, ToType,
Douglas Gregorc809cc22009-09-23 23:04:10 +00002217 /*FIXME:*/From->getLocStart(),
Anders Carlsson271e3a42009-08-27 17:30:43 +00002218 /*SuppressUserConversions=*/false,
2219 /*AllowExplicit=*/false,
2220 /*ForceRValue=*/false);
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00002221
Douglas Gregor7c3bbdf2009-12-16 03:45:30 +00002222 if (!PerformImplicitConversion(From, ToType, Action,
Sebastian Redl42e92c42009-04-12 17:16:29 +00002223 /*AllowExplicit=*/false, Elidable))
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00002224 return false;
Fariborz Jahanian76197412009-11-18 18:26:29 +00002225 if (!DiagnoseMultipleUserDefinedConversion(From, ToType))
Fariborz Jahanian0b51c722009-09-22 19:53:15 +00002226 return Diag(From->getSourceRange().getBegin(),
2227 diag::err_typecheck_convert_incompatible)
Douglas Gregor7c3bbdf2009-12-16 03:45:30 +00002228 << ToType << From->getType() << Action << From->getSourceRange();
Fariborz Jahanian0b51c722009-09-22 19:53:15 +00002229 return true;
Douglas Gregor8e1cf602008-10-29 00:13:59 +00002230}
2231
Douglas Gregor436424c2008-11-18 23:14:02 +00002232/// TryObjectArgumentInitialization - Try to initialize the object
2233/// parameter of the given member function (@c Method) from the
2234/// expression @p From.
2235ImplicitConversionSequence
John McCall47000992010-01-14 03:28:57 +00002236Sema::TryObjectArgumentInitialization(QualType OrigFromType,
John McCall6e9f8f62009-12-03 04:06:58 +00002237 CXXMethodDecl *Method,
2238 CXXRecordDecl *ActingContext) {
2239 QualType ClassType = Context.getTypeDeclType(ActingContext);
Sebastian Redl931e0bd2009-11-18 20:55:52 +00002240 // [class.dtor]p2: A destructor can be invoked for a const, volatile or
2241 // const volatile object.
2242 unsigned Quals = isa<CXXDestructorDecl>(Method) ?
2243 Qualifiers::Const | Qualifiers::Volatile : Method->getTypeQualifiers();
2244 QualType ImplicitParamType = Context.getCVRQualifiedType(ClassType, Quals);
Douglas Gregor436424c2008-11-18 23:14:02 +00002245
2246 // Set up the conversion sequence as a "bad" conversion, to allow us
2247 // to exit early.
2248 ImplicitConversionSequence ICS;
Douglas Gregor436424c2008-11-18 23:14:02 +00002249
2250 // We need to have an object of class type.
John McCall47000992010-01-14 03:28:57 +00002251 QualType FromType = OrigFromType;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002252 if (const PointerType *PT = FromType->getAs<PointerType>())
Anders Carlssonbfdea0f2009-05-01 18:34:30 +00002253 FromType = PT->getPointeeType();
2254
2255 assert(FromType->isRecordType());
Douglas Gregor436424c2008-11-18 23:14:02 +00002256
Sebastian Redl931e0bd2009-11-18 20:55:52 +00002257 // The implicit object parameter is has the type "reference to cv X",
Douglas Gregor436424c2008-11-18 23:14:02 +00002258 // where X is the class of which the function is a member
2259 // (C++ [over.match.funcs]p4). However, when finding an implicit
2260 // conversion sequence for the argument, we are not allowed to
Mike Stump11289f42009-09-09 15:08:12 +00002261 // create temporaries or perform user-defined conversions
Douglas Gregor436424c2008-11-18 23:14:02 +00002262 // (C++ [over.match.funcs]p5). We perform a simplified version of
2263 // reference binding here, that allows class rvalues to bind to
2264 // non-constant references.
2265
2266 // First check the qualifiers. We don't care about lvalue-vs-rvalue
2267 // with the implicit object parameter (C++ [over.match.funcs]p5).
2268 QualType FromTypeCanon = Context.getCanonicalType(FromType);
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00002269 if (ImplicitParamType.getCVRQualifiers()
2270 != FromTypeCanon.getLocalCVRQualifiers() &&
John McCall6a61b522010-01-13 09:16:55 +00002271 !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) {
John McCall65eb8792010-02-25 01:37:24 +00002272 ICS.setBad(BadConversionSequence::bad_qualifiers,
2273 OrigFromType, ImplicitParamType);
Douglas Gregor436424c2008-11-18 23:14:02 +00002274 return ICS;
John McCall6a61b522010-01-13 09:16:55 +00002275 }
Douglas Gregor436424c2008-11-18 23:14:02 +00002276
2277 // Check that we have either the same type or a derived type. It
2278 // affects the conversion rank.
2279 QualType ClassTypeCanon = Context.getCanonicalType(ClassType);
John McCall65eb8792010-02-25 01:37:24 +00002280 ImplicitConversionKind SecondKind;
2281 if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) {
2282 SecondKind = ICK_Identity;
2283 } else if (IsDerivedFrom(FromType, ClassType))
2284 SecondKind = ICK_Derived_To_Base;
John McCall6a61b522010-01-13 09:16:55 +00002285 else {
John McCall65eb8792010-02-25 01:37:24 +00002286 ICS.setBad(BadConversionSequence::unrelated_class,
2287 FromType, ImplicitParamType);
Douglas Gregor436424c2008-11-18 23:14:02 +00002288 return ICS;
John McCall6a61b522010-01-13 09:16:55 +00002289 }
Douglas Gregor436424c2008-11-18 23:14:02 +00002290
2291 // Success. Mark this as a reference binding.
John McCall0d1da222010-01-12 00:44:57 +00002292 ICS.setStandard();
John McCall65eb8792010-02-25 01:37:24 +00002293 ICS.Standard.setAsIdentityConversion();
2294 ICS.Standard.Second = SecondKind;
John McCall0d1da222010-01-12 00:44:57 +00002295 ICS.Standard.setFromType(FromType);
Douglas Gregor3edc4d52010-01-27 03:51:04 +00002296 ICS.Standard.setAllToTypes(ImplicitParamType);
Douglas Gregor436424c2008-11-18 23:14:02 +00002297 ICS.Standard.ReferenceBinding = true;
2298 ICS.Standard.DirectBinding = true;
Sebastian Redlf69a94a2009-03-29 22:46:24 +00002299 ICS.Standard.RRefBinding = false;
Douglas Gregor436424c2008-11-18 23:14:02 +00002300 return ICS;
2301}
2302
2303/// PerformObjectArgumentInitialization - Perform initialization of
2304/// the implicit object parameter for the given Method with the given
2305/// expression.
2306bool
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002307Sema::PerformObjectArgumentInitialization(Expr *&From,
2308 NestedNameSpecifier *Qualifier,
2309 CXXMethodDecl *Method) {
Anders Carlssonbfdea0f2009-05-01 18:34:30 +00002310 QualType FromRecordType, DestType;
Mike Stump11289f42009-09-09 15:08:12 +00002311 QualType ImplicitParamRecordType =
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002312 Method->getThisType(Context)->getAs<PointerType>()->getPointeeType();
Mike Stump11289f42009-09-09 15:08:12 +00002313
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002314 if (const PointerType *PT = From->getType()->getAs<PointerType>()) {
Anders Carlssonbfdea0f2009-05-01 18:34:30 +00002315 FromRecordType = PT->getPointeeType();
2316 DestType = Method->getThisType(Context);
2317 } else {
2318 FromRecordType = From->getType();
2319 DestType = ImplicitParamRecordType;
2320 }
2321
John McCall6e9f8f62009-12-03 04:06:58 +00002322 // Note that we always use the true parent context when performing
2323 // the actual argument initialization.
Mike Stump11289f42009-09-09 15:08:12 +00002324 ImplicitConversionSequence ICS
John McCall6e9f8f62009-12-03 04:06:58 +00002325 = TryObjectArgumentInitialization(From->getType(), Method,
2326 Method->getParent());
John McCall0d1da222010-01-12 00:44:57 +00002327 if (ICS.isBad())
Douglas Gregor436424c2008-11-18 23:14:02 +00002328 return Diag(From->getSourceRange().getBegin(),
Chris Lattner3b054132008-11-19 05:08:23 +00002329 diag::err_implicit_object_parameter_init)
Anders Carlssonbfdea0f2009-05-01 18:34:30 +00002330 << ImplicitParamRecordType << FromRecordType << From->getSourceRange();
Mike Stump11289f42009-09-09 15:08:12 +00002331
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002332 if (ICS.Standard.Second == ICK_Derived_To_Base)
2333 return PerformObjectMemberConversion(From, Qualifier, Method);
Douglas Gregor436424c2008-11-18 23:14:02 +00002334
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002335 if (!Context.hasSameType(From->getType(), DestType))
2336 ImpCastExprToType(From, DestType, CastExpr::CK_NoOp,
2337 /*isLvalue=*/!From->getType()->getAs<PointerType>());
Douglas Gregor436424c2008-11-18 23:14:02 +00002338 return false;
2339}
2340
Douglas Gregor5fb53972009-01-14 15:45:31 +00002341/// TryContextuallyConvertToBool - Attempt to contextually convert the
2342/// expression From to bool (C++0x [conv]p3).
2343ImplicitConversionSequence Sema::TryContextuallyConvertToBool(Expr *From) {
Mike Stump11289f42009-09-09 15:08:12 +00002344 return TryImplicitConversion(From, Context.BoolTy,
Anders Carlssonef4c7212009-08-27 17:24:15 +00002345 // FIXME: Are these flags correct?
2346 /*SuppressUserConversions=*/false,
Mike Stump11289f42009-09-09 15:08:12 +00002347 /*AllowExplicit=*/true,
Anders Carlsson228eea32009-08-28 15:33:32 +00002348 /*ForceRValue=*/false,
2349 /*InOverloadResolution=*/false);
Douglas Gregor5fb53972009-01-14 15:45:31 +00002350}
2351
2352/// PerformContextuallyConvertToBool - Perform a contextual conversion
2353/// of the expression From to bool (C++0x [conv]p3).
2354bool Sema::PerformContextuallyConvertToBool(Expr *&From) {
2355 ImplicitConversionSequence ICS = TryContextuallyConvertToBool(From);
John McCall0d1da222010-01-12 00:44:57 +00002356 if (!ICS.isBad())
2357 return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting);
Fariborz Jahanianf0647a52009-09-22 20:24:30 +00002358
Fariborz Jahanian76197412009-11-18 18:26:29 +00002359 if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy))
Fariborz Jahanianf0647a52009-09-22 20:24:30 +00002360 return Diag(From->getSourceRange().getBegin(),
2361 diag::err_typecheck_bool_condition)
2362 << From->getType() << From->getSourceRange();
2363 return true;
Douglas Gregor5fb53972009-01-14 15:45:31 +00002364}
2365
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002366/// AddOverloadCandidate - Adds the given function to the set of
Douglas Gregor2fe98832008-11-03 19:09:14 +00002367/// candidate functions, using the given function call arguments. If
2368/// @p SuppressUserConversions, then don't allow user-defined
2369/// conversions via constructors or conversion operators.
Sebastian Redl42e92c42009-04-12 17:16:29 +00002370/// If @p ForceRValue, treat all arguments as rvalues. This is a slightly
2371/// hacky way to implement the overloading rules for elidable copy
2372/// initialization in C++0x (C++0x 12.8p15).
Douglas Gregorcabea402009-09-22 15:41:20 +00002373///
2374/// \para PartialOverloading true if we are performing "partial" overloading
2375/// based on an incomplete set of function arguments. This feature is used by
2376/// code completion.
Mike Stump11289f42009-09-09 15:08:12 +00002377void
2378Sema::AddOverloadCandidate(FunctionDecl *Function,
John McCallb89836b2010-01-26 01:37:31 +00002379 AccessSpecifier Access,
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002380 Expr **Args, unsigned NumArgs,
Douglas Gregor2fe98832008-11-03 19:09:14 +00002381 OverloadCandidateSet& CandidateSet,
Sebastian Redl42e92c42009-04-12 17:16:29 +00002382 bool SuppressUserConversions,
Douglas Gregorcabea402009-09-22 15:41:20 +00002383 bool ForceRValue,
2384 bool PartialOverloading) {
Mike Stump11289f42009-09-09 15:08:12 +00002385 const FunctionProtoType* Proto
John McCall9dd450b2009-09-21 23:43:11 +00002386 = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002387 assert(Proto && "Functions without a prototype cannot be overloaded");
Mike Stump11289f42009-09-09 15:08:12 +00002388 assert(!Function->getDescribedFunctionTemplate() &&
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00002389 "Use AddTemplateOverloadCandidate for function templates");
Mike Stump11289f42009-09-09 15:08:12 +00002390
Douglas Gregor97fd6e22008-12-22 05:46:06 +00002391 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
Sebastian Redl1a99f442009-04-16 17:51:27 +00002392 if (!isa<CXXConstructorDecl>(Method)) {
2393 // If we get here, it's because we're calling a member function
2394 // that is named without a member access expression (e.g.,
2395 // "this->f") that was either written explicitly or created
2396 // implicitly. This can happen with a qualified call to a member
John McCall6e9f8f62009-12-03 04:06:58 +00002397 // function, e.g., X::f(). We use an empty type for the implied
2398 // object argument (C++ [over.call.func]p3), and the acting context
2399 // is irrelevant.
John McCallb89836b2010-01-26 01:37:31 +00002400 AddMethodCandidate(Method, Access, Method->getParent(),
John McCall6e9f8f62009-12-03 04:06:58 +00002401 QualType(), Args, NumArgs, CandidateSet,
Sebastian Redl1a99f442009-04-16 17:51:27 +00002402 SuppressUserConversions, ForceRValue);
2403 return;
2404 }
2405 // We treat a constructor like a non-member function, since its object
2406 // argument doesn't participate in overload resolution.
Douglas Gregor97fd6e22008-12-22 05:46:06 +00002407 }
2408
Douglas Gregorff7028a2009-11-13 23:59:09 +00002409 if (!CandidateSet.isNewCandidate(Function))
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002410 return;
Douglas Gregorffe14e32009-11-14 01:20:54 +00002411
Douglas Gregor27381f32009-11-23 12:27:39 +00002412 // Overload resolution is always an unevaluated context.
2413 EnterExpressionEvaluationContext Unevaluated(*this, Action::Unevaluated);
2414
Douglas Gregorffe14e32009-11-14 01:20:54 +00002415 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Function)){
2416 // C++ [class.copy]p3:
2417 // A member function template is never instantiated to perform the copy
2418 // of a class object to an object of its class type.
2419 QualType ClassType = Context.getTypeDeclType(Constructor->getParent());
2420 if (NumArgs == 1 &&
2421 Constructor->isCopyConstructorLikeSpecialization() &&
Douglas Gregor901e7172010-02-21 18:30:38 +00002422 (Context.hasSameUnqualifiedType(ClassType, Args[0]->getType()) ||
2423 IsDerivedFrom(Args[0]->getType(), ClassType)))
Douglas Gregorffe14e32009-11-14 01:20:54 +00002424 return;
2425 }
2426
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002427 // Add this candidate
2428 CandidateSet.push_back(OverloadCandidate());
2429 OverloadCandidate& Candidate = CandidateSet.back();
2430 Candidate.Function = Function;
John McCallb89836b2010-01-26 01:37:31 +00002431 Candidate.Access = Access;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00002432 Candidate.Viable = true;
Douglas Gregorab7897a2008-11-19 22:57:39 +00002433 Candidate.IsSurrogate = false;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00002434 Candidate.IgnoreObjectArgument = false;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002435
2436 unsigned NumArgsInProto = Proto->getNumArgs();
2437
2438 // (C++ 13.3.2p2): A candidate function having fewer than m
2439 // parameters is viable only if it has an ellipsis in its parameter
2440 // list (8.3.5).
Douglas Gregor2a920012009-09-23 14:56:09 +00002441 if ((NumArgs + (PartialOverloading && NumArgs)) > NumArgsInProto &&
2442 !Proto->isVariadic()) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002443 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002444 Candidate.FailureKind = ovl_fail_too_many_arguments;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002445 return;
2446 }
2447
2448 // (C++ 13.3.2p2): A candidate function having more than m parameters
2449 // is viable only if the (m+1)st parameter has a default argument
2450 // (8.3.6). For the purposes of overload resolution, the
2451 // parameter list is truncated on the right, so that there are
2452 // exactly m parameters.
2453 unsigned MinRequiredArgs = Function->getMinRequiredArguments();
Douglas Gregorcabea402009-09-22 15:41:20 +00002454 if (NumArgs < MinRequiredArgs && !PartialOverloading) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002455 // Not enough arguments.
2456 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002457 Candidate.FailureKind = ovl_fail_too_few_arguments;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002458 return;
2459 }
2460
2461 // Determine the implicit conversion sequences for each of the
2462 // arguments.
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002463 Candidate.Conversions.resize(NumArgs);
2464 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) {
2465 if (ArgIdx < NumArgsInProto) {
2466 // (C++ 13.3.2p3): for F to be a viable function, there shall
2467 // exist for each argument an implicit conversion sequence
2468 // (13.3.3.1) that converts that argument to the corresponding
2469 // parameter of F.
2470 QualType ParamType = Proto->getArgType(ArgIdx);
Mike Stump11289f42009-09-09 15:08:12 +00002471 Candidate.Conversions[ArgIdx]
2472 = TryCopyInitialization(Args[ArgIdx], ParamType,
Anders Carlsson20d13322009-08-27 17:37:39 +00002473 SuppressUserConversions, ForceRValue,
2474 /*InOverloadResolution=*/true);
John McCall0d1da222010-01-12 00:44:57 +00002475 if (Candidate.Conversions[ArgIdx].isBad()) {
2476 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002477 Candidate.FailureKind = ovl_fail_bad_conversion;
John McCall0d1da222010-01-12 00:44:57 +00002478 break;
Douglas Gregor436424c2008-11-18 23:14:02 +00002479 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002480 } else {
2481 // (C++ 13.3.2p2): For the purposes of overload resolution, any
2482 // argument for which there is no corresponding parameter is
2483 // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
John McCall0d1da222010-01-12 00:44:57 +00002484 Candidate.Conversions[ArgIdx].setEllipsis();
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002485 }
2486 }
2487}
2488
Douglas Gregor1baf54e2009-03-13 18:40:31 +00002489/// \brief Add all of the function declarations in the given function set to
2490/// the overload canddiate set.
John McCall4c4c1df2010-01-26 03:27:55 +00002491void Sema::AddFunctionCandidates(const UnresolvedSetImpl &Fns,
Douglas Gregor1baf54e2009-03-13 18:40:31 +00002492 Expr **Args, unsigned NumArgs,
2493 OverloadCandidateSet& CandidateSet,
2494 bool SuppressUserConversions) {
John McCall4c4c1df2010-01-26 03:27:55 +00002495 for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
John McCall6e9f8f62009-12-03 04:06:58 +00002496 // FIXME: using declarations
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002497 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*F)) {
2498 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
John McCall4c4c1df2010-01-26 03:27:55 +00002499 AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getAccess(),
John McCall6e9f8f62009-12-03 04:06:58 +00002500 cast<CXXMethodDecl>(FD)->getParent(),
2501 Args[0]->getType(), Args + 1, NumArgs - 1,
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002502 CandidateSet, SuppressUserConversions);
2503 else
John McCallb89836b2010-01-26 01:37:31 +00002504 AddOverloadCandidate(FD, AS_none, Args, NumArgs, CandidateSet,
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002505 SuppressUserConversions);
2506 } else {
2507 FunctionTemplateDecl *FunTmpl = cast<FunctionTemplateDecl>(*F);
2508 if (isa<CXXMethodDecl>(FunTmpl->getTemplatedDecl()) &&
2509 !cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl())->isStatic())
John McCall4c4c1df2010-01-26 03:27:55 +00002510 AddMethodTemplateCandidate(FunTmpl, F.getAccess(),
John McCall6e9f8f62009-12-03 04:06:58 +00002511 cast<CXXRecordDecl>(FunTmpl->getDeclContext()),
John McCall6b51f282009-11-23 01:53:49 +00002512 /*FIXME: explicit args */ 0,
John McCall6e9f8f62009-12-03 04:06:58 +00002513 Args[0]->getType(), Args + 1, NumArgs - 1,
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002514 CandidateSet,
Douglas Gregor15448f82009-06-27 21:05:07 +00002515 SuppressUserConversions);
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002516 else
John McCallb89836b2010-01-26 01:37:31 +00002517 AddTemplateOverloadCandidate(FunTmpl, AS_none,
John McCall6b51f282009-11-23 01:53:49 +00002518 /*FIXME: explicit args */ 0,
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002519 Args, NumArgs, CandidateSet,
2520 SuppressUserConversions);
2521 }
Douglas Gregor15448f82009-06-27 21:05:07 +00002522 }
Douglas Gregor1baf54e2009-03-13 18:40:31 +00002523}
2524
John McCallf0f1cf02009-11-17 07:50:12 +00002525/// AddMethodCandidate - Adds a named decl (which is some kind of
2526/// method) as a method candidate to the given overload set.
John McCall6e9f8f62009-12-03 04:06:58 +00002527void Sema::AddMethodCandidate(NamedDecl *Decl,
John McCallb89836b2010-01-26 01:37:31 +00002528 AccessSpecifier Access,
John McCall6e9f8f62009-12-03 04:06:58 +00002529 QualType ObjectType,
John McCallf0f1cf02009-11-17 07:50:12 +00002530 Expr **Args, unsigned NumArgs,
2531 OverloadCandidateSet& CandidateSet,
2532 bool SuppressUserConversions, bool ForceRValue) {
John McCall6e9f8f62009-12-03 04:06:58 +00002533 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(Decl->getDeclContext());
John McCallf0f1cf02009-11-17 07:50:12 +00002534
2535 if (isa<UsingShadowDecl>(Decl))
2536 Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl();
2537
2538 if (FunctionTemplateDecl *TD = dyn_cast<FunctionTemplateDecl>(Decl)) {
2539 assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
2540 "Expected a member function template");
John McCallb89836b2010-01-26 01:37:31 +00002541 AddMethodTemplateCandidate(TD, Access, ActingContext, /*ExplicitArgs*/ 0,
John McCall6e9f8f62009-12-03 04:06:58 +00002542 ObjectType, Args, NumArgs,
John McCallf0f1cf02009-11-17 07:50:12 +00002543 CandidateSet,
2544 SuppressUserConversions,
2545 ForceRValue);
2546 } else {
John McCallb89836b2010-01-26 01:37:31 +00002547 AddMethodCandidate(cast<CXXMethodDecl>(Decl), Access, ActingContext,
John McCall6e9f8f62009-12-03 04:06:58 +00002548 ObjectType, Args, NumArgs,
John McCallf0f1cf02009-11-17 07:50:12 +00002549 CandidateSet, SuppressUserConversions, ForceRValue);
2550 }
2551}
2552
Douglas Gregor436424c2008-11-18 23:14:02 +00002553/// AddMethodCandidate - Adds the given C++ member function to the set
2554/// of candidate functions, using the given function call arguments
2555/// and the object argument (@c Object). For example, in a call
2556/// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain
2557/// both @c a1 and @c a2. If @p SuppressUserConversions, then don't
2558/// allow user-defined conversions via constructors or conversion
Sebastian Redl42e92c42009-04-12 17:16:29 +00002559/// operators. If @p ForceRValue, treat all arguments as rvalues. This is
2560/// a slightly hacky way to implement the overloading rules for elidable copy
2561/// initialization in C++0x (C++0x 12.8p15).
Mike Stump11289f42009-09-09 15:08:12 +00002562void
John McCallb89836b2010-01-26 01:37:31 +00002563Sema::AddMethodCandidate(CXXMethodDecl *Method, AccessSpecifier Access,
2564 CXXRecordDecl *ActingContext, QualType ObjectType,
2565 Expr **Args, unsigned NumArgs,
Douglas Gregor436424c2008-11-18 23:14:02 +00002566 OverloadCandidateSet& CandidateSet,
Mike Stump11289f42009-09-09 15:08:12 +00002567 bool SuppressUserConversions, bool ForceRValue) {
2568 const FunctionProtoType* Proto
John McCall9dd450b2009-09-21 23:43:11 +00002569 = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
Douglas Gregor436424c2008-11-18 23:14:02 +00002570 assert(Proto && "Methods without a prototype cannot be overloaded");
Sebastian Redl1a99f442009-04-16 17:51:27 +00002571 assert(!isa<CXXConstructorDecl>(Method) &&
2572 "Use AddOverloadCandidate for constructors");
Douglas Gregor436424c2008-11-18 23:14:02 +00002573
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002574 if (!CandidateSet.isNewCandidate(Method))
2575 return;
2576
Douglas Gregor27381f32009-11-23 12:27:39 +00002577 // Overload resolution is always an unevaluated context.
2578 EnterExpressionEvaluationContext Unevaluated(*this, Action::Unevaluated);
2579
Douglas Gregor436424c2008-11-18 23:14:02 +00002580 // Add this candidate
2581 CandidateSet.push_back(OverloadCandidate());
2582 OverloadCandidate& Candidate = CandidateSet.back();
2583 Candidate.Function = Method;
John McCallb89836b2010-01-26 01:37:31 +00002584 Candidate.Access = Access;
Douglas Gregorab7897a2008-11-19 22:57:39 +00002585 Candidate.IsSurrogate = false;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00002586 Candidate.IgnoreObjectArgument = false;
Douglas Gregor436424c2008-11-18 23:14:02 +00002587
2588 unsigned NumArgsInProto = Proto->getNumArgs();
2589
2590 // (C++ 13.3.2p2): A candidate function having fewer than m
2591 // parameters is viable only if it has an ellipsis in its parameter
2592 // list (8.3.5).
2593 if (NumArgs > NumArgsInProto && !Proto->isVariadic()) {
2594 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002595 Candidate.FailureKind = ovl_fail_too_many_arguments;
Douglas Gregor436424c2008-11-18 23:14:02 +00002596 return;
2597 }
2598
2599 // (C++ 13.3.2p2): A candidate function having more than m parameters
2600 // is viable only if the (m+1)st parameter has a default argument
2601 // (8.3.6). For the purposes of overload resolution, the
2602 // parameter list is truncated on the right, so that there are
2603 // exactly m parameters.
2604 unsigned MinRequiredArgs = Method->getMinRequiredArguments();
2605 if (NumArgs < MinRequiredArgs) {
2606 // Not enough arguments.
2607 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002608 Candidate.FailureKind = ovl_fail_too_few_arguments;
Douglas Gregor436424c2008-11-18 23:14:02 +00002609 return;
2610 }
2611
2612 Candidate.Viable = true;
2613 Candidate.Conversions.resize(NumArgs + 1);
2614
John McCall6e9f8f62009-12-03 04:06:58 +00002615 if (Method->isStatic() || ObjectType.isNull())
Douglas Gregor97fd6e22008-12-22 05:46:06 +00002616 // The implicit object argument is ignored.
2617 Candidate.IgnoreObjectArgument = true;
2618 else {
2619 // Determine the implicit conversion sequence for the object
2620 // parameter.
John McCall6e9f8f62009-12-03 04:06:58 +00002621 Candidate.Conversions[0]
2622 = TryObjectArgumentInitialization(ObjectType, Method, ActingContext);
John McCall0d1da222010-01-12 00:44:57 +00002623 if (Candidate.Conversions[0].isBad()) {
Douglas Gregor97fd6e22008-12-22 05:46:06 +00002624 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002625 Candidate.FailureKind = ovl_fail_bad_conversion;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00002626 return;
2627 }
Douglas Gregor436424c2008-11-18 23:14:02 +00002628 }
2629
2630 // Determine the implicit conversion sequences for each of the
2631 // arguments.
2632 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) {
2633 if (ArgIdx < NumArgsInProto) {
2634 // (C++ 13.3.2p3): for F to be a viable function, there shall
2635 // exist for each argument an implicit conversion sequence
2636 // (13.3.3.1) that converts that argument to the corresponding
2637 // parameter of F.
2638 QualType ParamType = Proto->getArgType(ArgIdx);
Mike Stump11289f42009-09-09 15:08:12 +00002639 Candidate.Conversions[ArgIdx + 1]
2640 = TryCopyInitialization(Args[ArgIdx], ParamType,
Anders Carlsson20d13322009-08-27 17:37:39 +00002641 SuppressUserConversions, ForceRValue,
Anders Carlsson228eea32009-08-28 15:33:32 +00002642 /*InOverloadResolution=*/true);
John McCall0d1da222010-01-12 00:44:57 +00002643 if (Candidate.Conversions[ArgIdx + 1].isBad()) {
Douglas Gregor436424c2008-11-18 23:14:02 +00002644 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002645 Candidate.FailureKind = ovl_fail_bad_conversion;
Douglas Gregor436424c2008-11-18 23:14:02 +00002646 break;
2647 }
2648 } else {
2649 // (C++ 13.3.2p2): For the purposes of overload resolution, any
2650 // argument for which there is no corresponding parameter is
2651 // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
John McCall0d1da222010-01-12 00:44:57 +00002652 Candidate.Conversions[ArgIdx + 1].setEllipsis();
Douglas Gregor436424c2008-11-18 23:14:02 +00002653 }
2654 }
2655}
2656
Douglas Gregor97628d62009-08-21 00:16:32 +00002657/// \brief Add a C++ member function template as a candidate to the candidate
2658/// set, using template argument deduction to produce an appropriate member
2659/// function template specialization.
Mike Stump11289f42009-09-09 15:08:12 +00002660void
Douglas Gregor97628d62009-08-21 00:16:32 +00002661Sema::AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
John McCallb89836b2010-01-26 01:37:31 +00002662 AccessSpecifier Access,
John McCall6e9f8f62009-12-03 04:06:58 +00002663 CXXRecordDecl *ActingContext,
John McCall6b51f282009-11-23 01:53:49 +00002664 const TemplateArgumentListInfo *ExplicitTemplateArgs,
John McCall6e9f8f62009-12-03 04:06:58 +00002665 QualType ObjectType,
2666 Expr **Args, unsigned NumArgs,
Douglas Gregor97628d62009-08-21 00:16:32 +00002667 OverloadCandidateSet& CandidateSet,
2668 bool SuppressUserConversions,
2669 bool ForceRValue) {
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002670 if (!CandidateSet.isNewCandidate(MethodTmpl))
2671 return;
2672
Douglas Gregor97628d62009-08-21 00:16:32 +00002673 // C++ [over.match.funcs]p7:
Mike Stump11289f42009-09-09 15:08:12 +00002674 // In each case where a candidate is a function template, candidate
Douglas Gregor97628d62009-08-21 00:16:32 +00002675 // function template specializations are generated using template argument
Mike Stump11289f42009-09-09 15:08:12 +00002676 // deduction (14.8.3, 14.8.2). Those candidates are then handled as
Douglas Gregor97628d62009-08-21 00:16:32 +00002677 // candidate functions in the usual way.113) A given name can refer to one
2678 // or more function templates and also to a set of overloaded non-template
2679 // functions. In such a case, the candidate functions generated from each
2680 // function template are combined with the set of non-template candidate
2681 // functions.
John McCallbc077cf2010-02-08 23:07:23 +00002682 TemplateDeductionInfo Info(Context, CandidateSet.getLocation());
Douglas Gregor97628d62009-08-21 00:16:32 +00002683 FunctionDecl *Specialization = 0;
2684 if (TemplateDeductionResult Result
John McCall6b51f282009-11-23 01:53:49 +00002685 = DeduceTemplateArguments(MethodTmpl, ExplicitTemplateArgs,
Douglas Gregor97628d62009-08-21 00:16:32 +00002686 Args, NumArgs, Specialization, Info)) {
2687 // FIXME: Record what happened with template argument deduction, so
2688 // that we can give the user a beautiful diagnostic.
2689 (void)Result;
2690 return;
2691 }
Mike Stump11289f42009-09-09 15:08:12 +00002692
Douglas Gregor97628d62009-08-21 00:16:32 +00002693 // Add the function template specialization produced by template argument
2694 // deduction as a candidate.
2695 assert(Specialization && "Missing member function template specialization?");
Mike Stump11289f42009-09-09 15:08:12 +00002696 assert(isa<CXXMethodDecl>(Specialization) &&
Douglas Gregor97628d62009-08-21 00:16:32 +00002697 "Specialization is not a member function?");
John McCallb89836b2010-01-26 01:37:31 +00002698 AddMethodCandidate(cast<CXXMethodDecl>(Specialization), Access,
2699 ActingContext, ObjectType, Args, NumArgs,
Douglas Gregor97628d62009-08-21 00:16:32 +00002700 CandidateSet, SuppressUserConversions, ForceRValue);
2701}
2702
Douglas Gregor05155d82009-08-21 23:19:43 +00002703/// \brief Add a C++ function template specialization as a candidate
2704/// in the candidate set, using template argument deduction to produce
2705/// an appropriate function template specialization.
Mike Stump11289f42009-09-09 15:08:12 +00002706void
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00002707Sema::AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate,
John McCallb89836b2010-01-26 01:37:31 +00002708 AccessSpecifier Access,
John McCall6b51f282009-11-23 01:53:49 +00002709 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00002710 Expr **Args, unsigned NumArgs,
2711 OverloadCandidateSet& CandidateSet,
2712 bool SuppressUserConversions,
2713 bool ForceRValue) {
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002714 if (!CandidateSet.isNewCandidate(FunctionTemplate))
2715 return;
2716
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00002717 // C++ [over.match.funcs]p7:
Mike Stump11289f42009-09-09 15:08:12 +00002718 // In each case where a candidate is a function template, candidate
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00002719 // function template specializations are generated using template argument
Mike Stump11289f42009-09-09 15:08:12 +00002720 // deduction (14.8.3, 14.8.2). Those candidates are then handled as
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00002721 // candidate functions in the usual way.113) A given name can refer to one
2722 // or more function templates and also to a set of overloaded non-template
2723 // functions. In such a case, the candidate functions generated from each
2724 // function template are combined with the set of non-template candidate
2725 // functions.
John McCallbc077cf2010-02-08 23:07:23 +00002726 TemplateDeductionInfo Info(Context, CandidateSet.getLocation());
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00002727 FunctionDecl *Specialization = 0;
2728 if (TemplateDeductionResult Result
John McCall6b51f282009-11-23 01:53:49 +00002729 = DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs,
Douglas Gregor89026b52009-06-30 23:57:56 +00002730 Args, NumArgs, Specialization, Info)) {
John McCalld681c392009-12-16 08:11:27 +00002731 CandidateSet.push_back(OverloadCandidate());
2732 OverloadCandidate &Candidate = CandidateSet.back();
2733 Candidate.Function = FunctionTemplate->getTemplatedDecl();
John McCallb89836b2010-01-26 01:37:31 +00002734 Candidate.Access = Access;
John McCalld681c392009-12-16 08:11:27 +00002735 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002736 Candidate.FailureKind = ovl_fail_bad_deduction;
John McCalld681c392009-12-16 08:11:27 +00002737 Candidate.IsSurrogate = false;
2738 Candidate.IgnoreObjectArgument = false;
John McCall8b9ed552010-02-01 18:53:26 +00002739
2740 // TODO: record more information about failed template arguments
2741 Candidate.DeductionFailure.Result = Result;
2742 Candidate.DeductionFailure.TemplateParameter = Info.Param.getOpaqueValue();
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00002743 return;
2744 }
Mike Stump11289f42009-09-09 15:08:12 +00002745
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00002746 // Add the function template specialization produced by template argument
2747 // deduction as a candidate.
2748 assert(Specialization && "Missing function template specialization?");
John McCallb89836b2010-01-26 01:37:31 +00002749 AddOverloadCandidate(Specialization, Access, Args, NumArgs, CandidateSet,
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00002750 SuppressUserConversions, ForceRValue);
2751}
Mike Stump11289f42009-09-09 15:08:12 +00002752
Douglas Gregora1f013e2008-11-07 22:36:19 +00002753/// AddConversionCandidate - Add a C++ conversion function as a
Mike Stump11289f42009-09-09 15:08:12 +00002754/// candidate in the candidate set (C++ [over.match.conv],
Douglas Gregora1f013e2008-11-07 22:36:19 +00002755/// C++ [over.match.copy]). From is the expression we're converting from,
Mike Stump11289f42009-09-09 15:08:12 +00002756/// and ToType is the type that we're eventually trying to convert to
Douglas Gregora1f013e2008-11-07 22:36:19 +00002757/// (which may or may not be the same type as the type that the
2758/// conversion function produces).
2759void
2760Sema::AddConversionCandidate(CXXConversionDecl *Conversion,
John McCallb89836b2010-01-26 01:37:31 +00002761 AccessSpecifier Access,
John McCall6e9f8f62009-12-03 04:06:58 +00002762 CXXRecordDecl *ActingContext,
Douglas Gregora1f013e2008-11-07 22:36:19 +00002763 Expr *From, QualType ToType,
2764 OverloadCandidateSet& CandidateSet) {
Douglas Gregor05155d82009-08-21 23:19:43 +00002765 assert(!Conversion->getDescribedFunctionTemplate() &&
2766 "Conversion function templates use AddTemplateConversionCandidate");
2767
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002768 if (!CandidateSet.isNewCandidate(Conversion))
2769 return;
2770
Douglas Gregor27381f32009-11-23 12:27:39 +00002771 // Overload resolution is always an unevaluated context.
2772 EnterExpressionEvaluationContext Unevaluated(*this, Action::Unevaluated);
2773
Douglas Gregora1f013e2008-11-07 22:36:19 +00002774 // Add this candidate
2775 CandidateSet.push_back(OverloadCandidate());
2776 OverloadCandidate& Candidate = CandidateSet.back();
2777 Candidate.Function = Conversion;
John McCallb89836b2010-01-26 01:37:31 +00002778 Candidate.Access = Access;
Douglas Gregorab7897a2008-11-19 22:57:39 +00002779 Candidate.IsSurrogate = false;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00002780 Candidate.IgnoreObjectArgument = false;
Douglas Gregora1f013e2008-11-07 22:36:19 +00002781 Candidate.FinalConversion.setAsIdentityConversion();
John McCall0d1da222010-01-12 00:44:57 +00002782 Candidate.FinalConversion.setFromType(Conversion->getConversionType());
Douglas Gregor3edc4d52010-01-27 03:51:04 +00002783 Candidate.FinalConversion.setAllToTypes(ToType);
Douglas Gregora1f013e2008-11-07 22:36:19 +00002784
Douglas Gregor436424c2008-11-18 23:14:02 +00002785 // Determine the implicit conversion sequence for the implicit
2786 // object parameter.
Douglas Gregora1f013e2008-11-07 22:36:19 +00002787 Candidate.Viable = true;
2788 Candidate.Conversions.resize(1);
John McCall6e9f8f62009-12-03 04:06:58 +00002789 Candidate.Conversions[0]
2790 = TryObjectArgumentInitialization(From->getType(), Conversion,
2791 ActingContext);
Fariborz Jahanianf4061e32009-09-14 20:41:01 +00002792 // Conversion functions to a different type in the base class is visible in
2793 // the derived class. So, a derived to base conversion should not participate
2794 // in overload resolution.
2795 if (Candidate.Conversions[0].Standard.Second == ICK_Derived_To_Base)
2796 Candidate.Conversions[0].Standard.Second = ICK_Identity;
John McCall0d1da222010-01-12 00:44:57 +00002797 if (Candidate.Conversions[0].isBad()) {
Douglas Gregora1f013e2008-11-07 22:36:19 +00002798 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002799 Candidate.FailureKind = ovl_fail_bad_conversion;
Douglas Gregora1f013e2008-11-07 22:36:19 +00002800 return;
2801 }
Fariborz Jahanian996a6aa2009-10-19 19:18:20 +00002802
2803 // We won't go through a user-define type conversion function to convert a
2804 // derived to base as such conversions are given Conversion Rank. They only
2805 // go through a copy constructor. 13.3.3.1.2-p4 [over.ics.user]
2806 QualType FromCanon
2807 = Context.getCanonicalType(From->getType().getUnqualifiedType());
2808 QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
2809 if (FromCanon == ToCanon || IsDerivedFrom(FromCanon, ToCanon)) {
2810 Candidate.Viable = false;
John McCallfe796dd2010-01-23 05:17:32 +00002811 Candidate.FailureKind = ovl_fail_trivial_conversion;
Fariborz Jahanian996a6aa2009-10-19 19:18:20 +00002812 return;
2813 }
2814
Douglas Gregora1f013e2008-11-07 22:36:19 +00002815
2816 // To determine what the conversion from the result of calling the
2817 // conversion function to the type we're eventually trying to
2818 // convert to (ToType), we need to synthesize a call to the
2819 // conversion function and attempt copy initialization from it. This
2820 // makes sure that we get the right semantics with respect to
2821 // lvalues/rvalues and the type. Fortunately, we can allocate this
2822 // call on the stack and we don't need its arguments to be
2823 // well-formed.
Mike Stump11289f42009-09-09 15:08:12 +00002824 DeclRefExpr ConversionRef(Conversion, Conversion->getType(),
Douglas Gregore8f080122009-11-17 21:16:22 +00002825 From->getLocStart());
Douglas Gregora1f013e2008-11-07 22:36:19 +00002826 ImplicitCastExpr ConversionFn(Context.getPointerType(Conversion->getType()),
Eli Friedman06ed2a52009-10-20 08:27:19 +00002827 CastExpr::CK_FunctionToPointerDecay,
Douglas Gregora11693b2008-11-12 17:17:38 +00002828 &ConversionRef, false);
Mike Stump11289f42009-09-09 15:08:12 +00002829
2830 // Note that it is safe to allocate CallExpr on the stack here because
Ted Kremenekd7b4f402009-02-09 20:51:47 +00002831 // there are 0 arguments (i.e., nothing is allocated using ASTContext's
2832 // allocator).
Mike Stump11289f42009-09-09 15:08:12 +00002833 CallExpr Call(Context, &ConversionFn, 0, 0,
Douglas Gregora1f013e2008-11-07 22:36:19 +00002834 Conversion->getConversionType().getNonReferenceType(),
Douglas Gregore8f080122009-11-17 21:16:22 +00002835 From->getLocStart());
Mike Stump11289f42009-09-09 15:08:12 +00002836 ImplicitConversionSequence ICS =
2837 TryCopyInitialization(&Call, ToType,
Anders Carlsson03068aa2009-08-27 17:18:13 +00002838 /*SuppressUserConversions=*/true,
Anders Carlsson20d13322009-08-27 17:37:39 +00002839 /*ForceRValue=*/false,
2840 /*InOverloadResolution=*/false);
Mike Stump11289f42009-09-09 15:08:12 +00002841
John McCall0d1da222010-01-12 00:44:57 +00002842 switch (ICS.getKind()) {
Douglas Gregora1f013e2008-11-07 22:36:19 +00002843 case ImplicitConversionSequence::StandardConversion:
2844 Candidate.FinalConversion = ICS.Standard;
2845 break;
2846
2847 case ImplicitConversionSequence::BadConversion:
2848 Candidate.Viable = false;
John McCallfe796dd2010-01-23 05:17:32 +00002849 Candidate.FailureKind = ovl_fail_bad_final_conversion;
Douglas Gregora1f013e2008-11-07 22:36:19 +00002850 break;
2851
2852 default:
Mike Stump11289f42009-09-09 15:08:12 +00002853 assert(false &&
Douglas Gregora1f013e2008-11-07 22:36:19 +00002854 "Can only end up with a standard conversion sequence or failure");
2855 }
2856}
2857
Douglas Gregor05155d82009-08-21 23:19:43 +00002858/// \brief Adds a conversion function template specialization
2859/// candidate to the overload set, using template argument deduction
2860/// to deduce the template arguments of the conversion function
2861/// template from the type that we are converting to (C++
2862/// [temp.deduct.conv]).
Mike Stump11289f42009-09-09 15:08:12 +00002863void
Douglas Gregor05155d82009-08-21 23:19:43 +00002864Sema::AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate,
John McCallb89836b2010-01-26 01:37:31 +00002865 AccessSpecifier Access,
John McCall6e9f8f62009-12-03 04:06:58 +00002866 CXXRecordDecl *ActingDC,
Douglas Gregor05155d82009-08-21 23:19:43 +00002867 Expr *From, QualType ToType,
2868 OverloadCandidateSet &CandidateSet) {
2869 assert(isa<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()) &&
2870 "Only conversion function templates permitted here");
2871
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002872 if (!CandidateSet.isNewCandidate(FunctionTemplate))
2873 return;
2874
John McCallbc077cf2010-02-08 23:07:23 +00002875 TemplateDeductionInfo Info(Context, CandidateSet.getLocation());
Douglas Gregor05155d82009-08-21 23:19:43 +00002876 CXXConversionDecl *Specialization = 0;
2877 if (TemplateDeductionResult Result
Mike Stump11289f42009-09-09 15:08:12 +00002878 = DeduceTemplateArguments(FunctionTemplate, ToType,
Douglas Gregor05155d82009-08-21 23:19:43 +00002879 Specialization, Info)) {
2880 // FIXME: Record what happened with template argument deduction, so
2881 // that we can give the user a beautiful diagnostic.
2882 (void)Result;
2883 return;
2884 }
Mike Stump11289f42009-09-09 15:08:12 +00002885
Douglas Gregor05155d82009-08-21 23:19:43 +00002886 // Add the conversion function template specialization produced by
2887 // template argument deduction as a candidate.
2888 assert(Specialization && "Missing function template specialization?");
John McCallb89836b2010-01-26 01:37:31 +00002889 AddConversionCandidate(Specialization, Access, ActingDC, From, ToType,
2890 CandidateSet);
Douglas Gregor05155d82009-08-21 23:19:43 +00002891}
2892
Douglas Gregorab7897a2008-11-19 22:57:39 +00002893/// AddSurrogateCandidate - Adds a "surrogate" candidate function that
2894/// converts the given @c Object to a function pointer via the
2895/// conversion function @c Conversion, and then attempts to call it
2896/// with the given arguments (C++ [over.call.object]p2-4). Proto is
2897/// the type of function that we'll eventually be calling.
2898void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
John McCallb89836b2010-01-26 01:37:31 +00002899 AccessSpecifier Access,
John McCall6e9f8f62009-12-03 04:06:58 +00002900 CXXRecordDecl *ActingContext,
Douglas Gregordeaad8c2009-02-26 23:50:07 +00002901 const FunctionProtoType *Proto,
John McCall6e9f8f62009-12-03 04:06:58 +00002902 QualType ObjectType,
2903 Expr **Args, unsigned NumArgs,
Douglas Gregorab7897a2008-11-19 22:57:39 +00002904 OverloadCandidateSet& CandidateSet) {
Douglas Gregor5b0f2a22009-09-28 04:47:19 +00002905 if (!CandidateSet.isNewCandidate(Conversion))
2906 return;
2907
Douglas Gregor27381f32009-11-23 12:27:39 +00002908 // Overload resolution is always an unevaluated context.
2909 EnterExpressionEvaluationContext Unevaluated(*this, Action::Unevaluated);
2910
Douglas Gregorab7897a2008-11-19 22:57:39 +00002911 CandidateSet.push_back(OverloadCandidate());
2912 OverloadCandidate& Candidate = CandidateSet.back();
2913 Candidate.Function = 0;
John McCallb89836b2010-01-26 01:37:31 +00002914 Candidate.Access = Access;
Douglas Gregorab7897a2008-11-19 22:57:39 +00002915 Candidate.Surrogate = Conversion;
2916 Candidate.Viable = true;
2917 Candidate.IsSurrogate = true;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00002918 Candidate.IgnoreObjectArgument = false;
Douglas Gregorab7897a2008-11-19 22:57:39 +00002919 Candidate.Conversions.resize(NumArgs + 1);
2920
2921 // Determine the implicit conversion sequence for the implicit
2922 // object parameter.
Mike Stump11289f42009-09-09 15:08:12 +00002923 ImplicitConversionSequence ObjectInit
John McCall6e9f8f62009-12-03 04:06:58 +00002924 = TryObjectArgumentInitialization(ObjectType, Conversion, ActingContext);
John McCall0d1da222010-01-12 00:44:57 +00002925 if (ObjectInit.isBad()) {
Douglas Gregorab7897a2008-11-19 22:57:39 +00002926 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002927 Candidate.FailureKind = ovl_fail_bad_conversion;
John McCallfe796dd2010-01-23 05:17:32 +00002928 Candidate.Conversions[0] = ObjectInit;
Douglas Gregorab7897a2008-11-19 22:57:39 +00002929 return;
2930 }
2931
2932 // The first conversion is actually a user-defined conversion whose
2933 // first conversion is ObjectInit's standard conversion (which is
2934 // effectively a reference binding). Record it as such.
John McCall0d1da222010-01-12 00:44:57 +00002935 Candidate.Conversions[0].setUserDefined();
Douglas Gregorab7897a2008-11-19 22:57:39 +00002936 Candidate.Conversions[0].UserDefined.Before = ObjectInit.Standard;
Fariborz Jahanian55824512009-11-06 00:23:08 +00002937 Candidate.Conversions[0].UserDefined.EllipsisConversion = false;
Douglas Gregorab7897a2008-11-19 22:57:39 +00002938 Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion;
Mike Stump11289f42009-09-09 15:08:12 +00002939 Candidate.Conversions[0].UserDefined.After
Douglas Gregorab7897a2008-11-19 22:57:39 +00002940 = Candidate.Conversions[0].UserDefined.Before;
2941 Candidate.Conversions[0].UserDefined.After.setAsIdentityConversion();
2942
Mike Stump11289f42009-09-09 15:08:12 +00002943 // Find the
Douglas Gregorab7897a2008-11-19 22:57:39 +00002944 unsigned NumArgsInProto = Proto->getNumArgs();
2945
2946 // (C++ 13.3.2p2): A candidate function having fewer than m
2947 // parameters is viable only if it has an ellipsis in its parameter
2948 // list (8.3.5).
2949 if (NumArgs > NumArgsInProto && !Proto->isVariadic()) {
2950 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002951 Candidate.FailureKind = ovl_fail_too_many_arguments;
Douglas Gregorab7897a2008-11-19 22:57:39 +00002952 return;
2953 }
2954
2955 // Function types don't have any default arguments, so just check if
2956 // we have enough arguments.
2957 if (NumArgs < NumArgsInProto) {
2958 // Not enough arguments.
2959 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002960 Candidate.FailureKind = ovl_fail_too_few_arguments;
Douglas Gregorab7897a2008-11-19 22:57:39 +00002961 return;
2962 }
2963
2964 // Determine the implicit conversion sequences for each of the
2965 // arguments.
2966 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) {
2967 if (ArgIdx < NumArgsInProto) {
2968 // (C++ 13.3.2p3): for F to be a viable function, there shall
2969 // exist for each argument an implicit conversion sequence
2970 // (13.3.3.1) that converts that argument to the corresponding
2971 // parameter of F.
2972 QualType ParamType = Proto->getArgType(ArgIdx);
Mike Stump11289f42009-09-09 15:08:12 +00002973 Candidate.Conversions[ArgIdx + 1]
2974 = TryCopyInitialization(Args[ArgIdx], ParamType,
Anders Carlsson03068aa2009-08-27 17:18:13 +00002975 /*SuppressUserConversions=*/false,
Anders Carlsson20d13322009-08-27 17:37:39 +00002976 /*ForceRValue=*/false,
2977 /*InOverloadResolution=*/false);
John McCall0d1da222010-01-12 00:44:57 +00002978 if (Candidate.Conversions[ArgIdx + 1].isBad()) {
Douglas Gregorab7897a2008-11-19 22:57:39 +00002979 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00002980 Candidate.FailureKind = ovl_fail_bad_conversion;
Douglas Gregorab7897a2008-11-19 22:57:39 +00002981 break;
2982 }
2983 } else {
2984 // (C++ 13.3.2p2): For the purposes of overload resolution, any
2985 // argument for which there is no corresponding parameter is
2986 // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
John McCall0d1da222010-01-12 00:44:57 +00002987 Candidate.Conversions[ArgIdx + 1].setEllipsis();
Douglas Gregorab7897a2008-11-19 22:57:39 +00002988 }
2989 }
2990}
2991
Mike Stump87c57ac2009-05-16 07:39:55 +00002992// FIXME: This will eventually be removed, once we've migrated all of the
2993// operator overloading logic over to the scheme used by binary operators, which
2994// works for template instantiation.
Douglas Gregor1baf54e2009-03-13 18:40:31 +00002995void Sema::AddOperatorCandidates(OverloadedOperatorKind Op, Scope *S,
Douglas Gregor94eabf32009-02-04 16:44:47 +00002996 SourceLocation OpLoc,
Douglas Gregor436424c2008-11-18 23:14:02 +00002997 Expr **Args, unsigned NumArgs,
Douglas Gregor94eabf32009-02-04 16:44:47 +00002998 OverloadCandidateSet& CandidateSet,
2999 SourceRange OpRange) {
John McCall4c4c1df2010-01-26 03:27:55 +00003000 UnresolvedSet<16> Fns;
Douglas Gregor1baf54e2009-03-13 18:40:31 +00003001
3002 QualType T1 = Args[0]->getType();
3003 QualType T2;
3004 if (NumArgs > 1)
3005 T2 = Args[1]->getType();
3006
3007 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
Douglas Gregor7a77a6b2009-05-19 00:01:19 +00003008 if (S)
John McCall4c4c1df2010-01-26 03:27:55 +00003009 LookupOverloadedOperatorName(Op, S, T1, T2, Fns);
3010 AddFunctionCandidates(Fns, Args, NumArgs, CandidateSet, false);
3011 AddArgumentDependentLookupCandidates(OpName, false, Args, NumArgs, 0,
3012 CandidateSet);
Douglas Gregor1baf54e2009-03-13 18:40:31 +00003013 AddMemberOperatorCandidates(Op, OpLoc, Args, NumArgs, CandidateSet, OpRange);
Douglas Gregorc02cfe22009-10-21 23:19:44 +00003014 AddBuiltinOperatorCandidates(Op, OpLoc, Args, NumArgs, CandidateSet);
Douglas Gregor1baf54e2009-03-13 18:40:31 +00003015}
3016
3017/// \brief Add overload candidates for overloaded operators that are
3018/// member functions.
3019///
3020/// Add the overloaded operator candidates that are member functions
3021/// for the operator Op that was used in an operator expression such
3022/// as "x Op y". , Args/NumArgs provides the operator arguments, and
3023/// CandidateSet will store the added overload candidates. (C++
3024/// [over.match.oper]).
3025void Sema::AddMemberOperatorCandidates(OverloadedOperatorKind Op,
3026 SourceLocation OpLoc,
3027 Expr **Args, unsigned NumArgs,
3028 OverloadCandidateSet& CandidateSet,
3029 SourceRange OpRange) {
Douglas Gregor436424c2008-11-18 23:14:02 +00003030 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
3031
3032 // C++ [over.match.oper]p3:
3033 // For a unary operator @ with an operand of a type whose
3034 // cv-unqualified version is T1, and for a binary operator @ with
3035 // a left operand of a type whose cv-unqualified version is T1 and
3036 // a right operand of a type whose cv-unqualified version is T2,
3037 // three sets of candidate functions, designated member
3038 // candidates, non-member candidates and built-in candidates, are
3039 // constructed as follows:
3040 QualType T1 = Args[0]->getType();
3041 QualType T2;
3042 if (NumArgs > 1)
3043 T2 = Args[1]->getType();
3044
3045 // -- If T1 is a class type, the set of member candidates is the
3046 // result of the qualified lookup of T1::operator@
3047 // (13.3.1.1.1); otherwise, the set of member candidates is
3048 // empty.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003049 if (const RecordType *T1Rec = T1->getAs<RecordType>()) {
Douglas Gregor6a1f9652009-08-27 23:35:55 +00003050 // Complete the type if it can be completed. Otherwise, we're done.
Anders Carlsson7f84ed92009-10-09 23:51:55 +00003051 if (RequireCompleteType(OpLoc, T1, PDiag()))
Douglas Gregor6a1f9652009-08-27 23:35:55 +00003052 return;
Mike Stump11289f42009-09-09 15:08:12 +00003053
John McCall27b18f82009-11-17 02:14:36 +00003054 LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName);
3055 LookupQualifiedName(Operators, T1Rec->getDecl());
3056 Operators.suppressDiagnostics();
3057
Mike Stump11289f42009-09-09 15:08:12 +00003058 for (LookupResult::iterator Oper = Operators.begin(),
Douglas Gregor6a1f9652009-08-27 23:35:55 +00003059 OperEnd = Operators.end();
3060 Oper != OperEnd;
John McCallf0f1cf02009-11-17 07:50:12 +00003061 ++Oper)
John McCallb89836b2010-01-26 01:37:31 +00003062 AddMethodCandidate(*Oper, Oper.getAccess(), Args[0]->getType(),
John McCall6e9f8f62009-12-03 04:06:58 +00003063 Args + 1, NumArgs - 1, CandidateSet,
John McCallf0f1cf02009-11-17 07:50:12 +00003064 /* SuppressUserConversions = */ false);
Douglas Gregor436424c2008-11-18 23:14:02 +00003065 }
Douglas Gregor436424c2008-11-18 23:14:02 +00003066}
3067
Douglas Gregora11693b2008-11-12 17:17:38 +00003068/// AddBuiltinCandidate - Add a candidate for a built-in
3069/// operator. ResultTy and ParamTys are the result and parameter types
3070/// of the built-in candidate, respectively. Args and NumArgs are the
Douglas Gregorc5e61072009-01-13 00:52:54 +00003071/// arguments being passed to the candidate. IsAssignmentOperator
3072/// should be true when this built-in candidate is an assignment
Douglas Gregor5fb53972009-01-14 15:45:31 +00003073/// operator. NumContextualBoolArguments is the number of arguments
3074/// (at the beginning of the argument list) that will be contextually
3075/// converted to bool.
Mike Stump11289f42009-09-09 15:08:12 +00003076void Sema::AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys,
Douglas Gregora11693b2008-11-12 17:17:38 +00003077 Expr **Args, unsigned NumArgs,
Douglas Gregorc5e61072009-01-13 00:52:54 +00003078 OverloadCandidateSet& CandidateSet,
Douglas Gregor5fb53972009-01-14 15:45:31 +00003079 bool IsAssignmentOperator,
3080 unsigned NumContextualBoolArguments) {
Douglas Gregor27381f32009-11-23 12:27:39 +00003081 // Overload resolution is always an unevaluated context.
3082 EnterExpressionEvaluationContext Unevaluated(*this, Action::Unevaluated);
3083
Douglas Gregora11693b2008-11-12 17:17:38 +00003084 // Add this candidate
3085 CandidateSet.push_back(OverloadCandidate());
3086 OverloadCandidate& Candidate = CandidateSet.back();
3087 Candidate.Function = 0;
John McCallb89836b2010-01-26 01:37:31 +00003088 Candidate.Access = AS_none;
Douglas Gregor1d248c52008-12-12 02:00:36 +00003089 Candidate.IsSurrogate = false;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00003090 Candidate.IgnoreObjectArgument = false;
Douglas Gregora11693b2008-11-12 17:17:38 +00003091 Candidate.BuiltinTypes.ResultTy = ResultTy;
3092 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx)
3093 Candidate.BuiltinTypes.ParamTypes[ArgIdx] = ParamTys[ArgIdx];
3094
3095 // Determine the implicit conversion sequences for each of the
3096 // arguments.
3097 Candidate.Viable = true;
3098 Candidate.Conversions.resize(NumArgs);
3099 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) {
Douglas Gregorc5e61072009-01-13 00:52:54 +00003100 // C++ [over.match.oper]p4:
3101 // For the built-in assignment operators, conversions of the
3102 // left operand are restricted as follows:
3103 // -- no temporaries are introduced to hold the left operand, and
3104 // -- no user-defined conversions are applied to the left
3105 // operand to achieve a type match with the left-most
Mike Stump11289f42009-09-09 15:08:12 +00003106 // parameter of a built-in candidate.
Douglas Gregorc5e61072009-01-13 00:52:54 +00003107 //
3108 // We block these conversions by turning off user-defined
3109 // conversions, since that is the only way that initialization of
3110 // a reference to a non-class type can occur from something that
3111 // is not of the same type.
Douglas Gregor5fb53972009-01-14 15:45:31 +00003112 if (ArgIdx < NumContextualBoolArguments) {
Mike Stump11289f42009-09-09 15:08:12 +00003113 assert(ParamTys[ArgIdx] == Context.BoolTy &&
Douglas Gregor5fb53972009-01-14 15:45:31 +00003114 "Contextual conversion to bool requires bool type");
3115 Candidate.Conversions[ArgIdx] = TryContextuallyConvertToBool(Args[ArgIdx]);
3116 } else {
Mike Stump11289f42009-09-09 15:08:12 +00003117 Candidate.Conversions[ArgIdx]
3118 = TryCopyInitialization(Args[ArgIdx], ParamTys[ArgIdx],
Anders Carlsson03068aa2009-08-27 17:18:13 +00003119 ArgIdx == 0 && IsAssignmentOperator,
Anders Carlsson20d13322009-08-27 17:37:39 +00003120 /*ForceRValue=*/false,
3121 /*InOverloadResolution=*/false);
Douglas Gregor5fb53972009-01-14 15:45:31 +00003122 }
John McCall0d1da222010-01-12 00:44:57 +00003123 if (Candidate.Conversions[ArgIdx].isBad()) {
Douglas Gregora11693b2008-11-12 17:17:38 +00003124 Candidate.Viable = false;
John McCall6a61b522010-01-13 09:16:55 +00003125 Candidate.FailureKind = ovl_fail_bad_conversion;
Douglas Gregor436424c2008-11-18 23:14:02 +00003126 break;
3127 }
Douglas Gregora11693b2008-11-12 17:17:38 +00003128 }
3129}
3130
3131/// BuiltinCandidateTypeSet - A set of types that will be used for the
3132/// candidate operator functions for built-in operators (C++
3133/// [over.built]). The types are separated into pointer types and
3134/// enumeration types.
3135class BuiltinCandidateTypeSet {
3136 /// TypeSet - A set of types.
Chris Lattnera59a3e22009-03-29 00:04:01 +00003137 typedef llvm::SmallPtrSet<QualType, 8> TypeSet;
Douglas Gregora11693b2008-11-12 17:17:38 +00003138
3139 /// PointerTypes - The set of pointer types that will be used in the
3140 /// built-in candidates.
3141 TypeSet PointerTypes;
3142
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003143 /// MemberPointerTypes - The set of member pointer types that will be
3144 /// used in the built-in candidates.
3145 TypeSet MemberPointerTypes;
3146
Douglas Gregora11693b2008-11-12 17:17:38 +00003147 /// EnumerationTypes - The set of enumeration types that will be
3148 /// used in the built-in candidates.
3149 TypeSet EnumerationTypes;
3150
Douglas Gregor8a2e6012009-08-24 15:23:48 +00003151 /// Sema - The semantic analysis instance where we are building the
3152 /// candidate type set.
3153 Sema &SemaRef;
Mike Stump11289f42009-09-09 15:08:12 +00003154
Douglas Gregora11693b2008-11-12 17:17:38 +00003155 /// Context - The AST context in which we will build the type sets.
3156 ASTContext &Context;
3157
Fariborz Jahanianb06ec052009-10-16 22:08:05 +00003158 bool AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
3159 const Qualifiers &VisibleQuals);
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003160 bool AddMemberPointerWithMoreQualifiedTypeVariants(QualType Ty);
Douglas Gregora11693b2008-11-12 17:17:38 +00003161
3162public:
3163 /// iterator - Iterates through the types that are part of the set.
Chris Lattnera59a3e22009-03-29 00:04:01 +00003164 typedef TypeSet::iterator iterator;
Douglas Gregora11693b2008-11-12 17:17:38 +00003165
Mike Stump11289f42009-09-09 15:08:12 +00003166 BuiltinCandidateTypeSet(Sema &SemaRef)
Douglas Gregor8a2e6012009-08-24 15:23:48 +00003167 : SemaRef(SemaRef), Context(SemaRef.Context) { }
Douglas Gregora11693b2008-11-12 17:17:38 +00003168
Douglas Gregorc02cfe22009-10-21 23:19:44 +00003169 void AddTypesConvertedFrom(QualType Ty,
3170 SourceLocation Loc,
3171 bool AllowUserConversions,
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00003172 bool AllowExplicitConversions,
3173 const Qualifiers &VisibleTypeConversionsQuals);
Douglas Gregora11693b2008-11-12 17:17:38 +00003174
3175 /// pointer_begin - First pointer type found;
3176 iterator pointer_begin() { return PointerTypes.begin(); }
3177
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003178 /// pointer_end - Past the last pointer type found;
Douglas Gregora11693b2008-11-12 17:17:38 +00003179 iterator pointer_end() { return PointerTypes.end(); }
3180
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003181 /// member_pointer_begin - First member pointer type found;
3182 iterator member_pointer_begin() { return MemberPointerTypes.begin(); }
3183
3184 /// member_pointer_end - Past the last member pointer type found;
3185 iterator member_pointer_end() { return MemberPointerTypes.end(); }
3186
Douglas Gregora11693b2008-11-12 17:17:38 +00003187 /// enumeration_begin - First enumeration type found;
3188 iterator enumeration_begin() { return EnumerationTypes.begin(); }
3189
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003190 /// enumeration_end - Past the last enumeration type found;
Douglas Gregora11693b2008-11-12 17:17:38 +00003191 iterator enumeration_end() { return EnumerationTypes.end(); }
3192};
3193
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003194/// AddPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty to
Douglas Gregora11693b2008-11-12 17:17:38 +00003195/// the set of pointer types along with any more-qualified variants of
3196/// that type. For example, if @p Ty is "int const *", this routine
3197/// will add "int const *", "int const volatile *", "int const
3198/// restrict *", and "int const volatile restrict *" to the set of
3199/// pointer types. Returns true if the add of @p Ty itself succeeded,
3200/// false otherwise.
John McCall8ccfcb52009-09-24 19:53:00 +00003201///
3202/// FIXME: what to do about extended qualifiers?
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003203bool
Douglas Gregorc02cfe22009-10-21 23:19:44 +00003204BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
3205 const Qualifiers &VisibleQuals) {
John McCall8ccfcb52009-09-24 19:53:00 +00003206
Douglas Gregora11693b2008-11-12 17:17:38 +00003207 // Insert this type.
Chris Lattnera59a3e22009-03-29 00:04:01 +00003208 if (!PointerTypes.insert(Ty))
Douglas Gregora11693b2008-11-12 17:17:38 +00003209 return false;
3210
John McCall8ccfcb52009-09-24 19:53:00 +00003211 const PointerType *PointerTy = Ty->getAs<PointerType>();
3212 assert(PointerTy && "type was not a pointer type!");
Douglas Gregora11693b2008-11-12 17:17:38 +00003213
John McCall8ccfcb52009-09-24 19:53:00 +00003214 QualType PointeeTy = PointerTy->getPointeeType();
Sebastian Redl4990a632009-11-18 20:39:26 +00003215 // Don't add qualified variants of arrays. For one, they're not allowed
3216 // (the qualifier would sink to the element type), and for another, the
3217 // only overload situation where it matters is subscript or pointer +- int,
3218 // and those shouldn't have qualifier variants anyway.
3219 if (PointeeTy->isArrayType())
3220 return true;
John McCall8ccfcb52009-09-24 19:53:00 +00003221 unsigned BaseCVR = PointeeTy.getCVRQualifiers();
Douglas Gregor4ef1d402009-11-09 22:08:55 +00003222 if (const ConstantArrayType *Array =Context.getAsConstantArrayType(PointeeTy))
Fariborz Jahanianfacfdd42009-11-09 21:02:05 +00003223 BaseCVR = Array->getElementType().getCVRQualifiers();
Fariborz Jahanianb06ec052009-10-16 22:08:05 +00003224 bool hasVolatile = VisibleQuals.hasVolatile();
3225 bool hasRestrict = VisibleQuals.hasRestrict();
3226
John McCall8ccfcb52009-09-24 19:53:00 +00003227 // Iterate through all strict supersets of BaseCVR.
3228 for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
3229 if ((CVR | BaseCVR) != CVR) continue;
Fariborz Jahanianb06ec052009-10-16 22:08:05 +00003230 // Skip over Volatile/Restrict if no Volatile/Restrict found anywhere
3231 // in the types.
3232 if ((CVR & Qualifiers::Volatile) && !hasVolatile) continue;
3233 if ((CVR & Qualifiers::Restrict) && !hasRestrict) continue;
John McCall8ccfcb52009-09-24 19:53:00 +00003234 QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
3235 PointerTypes.insert(Context.getPointerType(QPointeeTy));
Douglas Gregora11693b2008-11-12 17:17:38 +00003236 }
3237
3238 return true;
3239}
3240
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003241/// AddMemberPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty
3242/// to the set of pointer types along with any more-qualified variants of
3243/// that type. For example, if @p Ty is "int const *", this routine
3244/// will add "int const *", "int const volatile *", "int const
3245/// restrict *", and "int const volatile restrict *" to the set of
3246/// pointer types. Returns true if the add of @p Ty itself succeeded,
3247/// false otherwise.
John McCall8ccfcb52009-09-24 19:53:00 +00003248///
3249/// FIXME: what to do about extended qualifiers?
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003250bool
3251BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
3252 QualType Ty) {
3253 // Insert this type.
3254 if (!MemberPointerTypes.insert(Ty))
3255 return false;
3256
John McCall8ccfcb52009-09-24 19:53:00 +00003257 const MemberPointerType *PointerTy = Ty->getAs<MemberPointerType>();
3258 assert(PointerTy && "type was not a member pointer type!");
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003259
John McCall8ccfcb52009-09-24 19:53:00 +00003260 QualType PointeeTy = PointerTy->getPointeeType();
Sebastian Redl4990a632009-11-18 20:39:26 +00003261 // Don't add qualified variants of arrays. For one, they're not allowed
3262 // (the qualifier would sink to the element type), and for another, the
3263 // only overload situation where it matters is subscript or pointer +- int,
3264 // and those shouldn't have qualifier variants anyway.
3265 if (PointeeTy->isArrayType())
3266 return true;
John McCall8ccfcb52009-09-24 19:53:00 +00003267 const Type *ClassTy = PointerTy->getClass();
3268
3269 // Iterate through all strict supersets of the pointee type's CVR
3270 // qualifiers.
3271 unsigned BaseCVR = PointeeTy.getCVRQualifiers();
3272 for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
3273 if ((CVR | BaseCVR) != CVR) continue;
3274
3275 QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
3276 MemberPointerTypes.insert(Context.getMemberPointerType(QPointeeTy, ClassTy));
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003277 }
3278
3279 return true;
3280}
3281
Douglas Gregora11693b2008-11-12 17:17:38 +00003282/// AddTypesConvertedFrom - Add each of the types to which the type @p
3283/// Ty can be implicit converted to the given set of @p Types. We're
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003284/// primarily interested in pointer types and enumeration types. We also
3285/// take member pointer types, for the conditional operator.
Douglas Gregor5fb53972009-01-14 15:45:31 +00003286/// AllowUserConversions is true if we should look at the conversion
3287/// functions of a class type, and AllowExplicitConversions if we
3288/// should also include the explicit conversion functions of a class
3289/// type.
Mike Stump11289f42009-09-09 15:08:12 +00003290void
Douglas Gregor5fb53972009-01-14 15:45:31 +00003291BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty,
Douglas Gregorc02cfe22009-10-21 23:19:44 +00003292 SourceLocation Loc,
Douglas Gregor5fb53972009-01-14 15:45:31 +00003293 bool AllowUserConversions,
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00003294 bool AllowExplicitConversions,
3295 const Qualifiers &VisibleQuals) {
Douglas Gregora11693b2008-11-12 17:17:38 +00003296 // Only deal with canonical types.
3297 Ty = Context.getCanonicalType(Ty);
3298
3299 // Look through reference types; they aren't part of the type of an
3300 // expression for the purposes of conversions.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003301 if (const ReferenceType *RefTy = Ty->getAs<ReferenceType>())
Douglas Gregora11693b2008-11-12 17:17:38 +00003302 Ty = RefTy->getPointeeType();
3303
3304 // We don't care about qualifiers on the type.
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00003305 Ty = Ty.getLocalUnqualifiedType();
Douglas Gregora11693b2008-11-12 17:17:38 +00003306
Sebastian Redl65ae2002009-11-05 16:36:20 +00003307 // If we're dealing with an array type, decay to the pointer.
3308 if (Ty->isArrayType())
3309 Ty = SemaRef.Context.getArrayDecayedType(Ty);
3310
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003311 if (const PointerType *PointerTy = Ty->getAs<PointerType>()) {
Douglas Gregora11693b2008-11-12 17:17:38 +00003312 QualType PointeeTy = PointerTy->getPointeeType();
3313
3314 // Insert our type, and its more-qualified variants, into the set
3315 // of types.
Fariborz Jahanianb06ec052009-10-16 22:08:05 +00003316 if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
Douglas Gregora11693b2008-11-12 17:17:38 +00003317 return;
Sebastian Redl8ce189f2009-04-19 21:53:20 +00003318 } else if (Ty->isMemberPointerType()) {
3319 // Member pointers are far easier, since the pointee can't be converted.
3320 if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
3321 return;
Douglas Gregora11693b2008-11-12 17:17:38 +00003322 } else if (Ty->isEnumeralType()) {
Chris Lattnera59a3e22009-03-29 00:04:01 +00003323 EnumerationTypes.insert(Ty);
Douglas Gregora11693b2008-11-12 17:17:38 +00003324 } else if (AllowUserConversions) {
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003325 if (const RecordType *TyRec = Ty->getAs<RecordType>()) {
Douglas Gregorc02cfe22009-10-21 23:19:44 +00003326 if (SemaRef.RequireCompleteType(Loc, Ty, 0)) {
Douglas Gregor8a2e6012009-08-24 15:23:48 +00003327 // No conversion functions in incomplete types.
3328 return;
3329 }
Mike Stump11289f42009-09-09 15:08:12 +00003330
Douglas Gregora11693b2008-11-12 17:17:38 +00003331 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
John McCallad371252010-01-20 00:46:10 +00003332 const UnresolvedSetImpl *Conversions
Fariborz Jahanianae01f782009-10-07 17:26:09 +00003333 = ClassDecl->getVisibleConversionFunctions();
John McCallad371252010-01-20 00:46:10 +00003334 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
John McCalld14a8642009-11-21 08:51:07 +00003335 E = Conversions->end(); I != E; ++I) {
Douglas Gregor05155d82009-08-21 23:19:43 +00003336
Mike Stump11289f42009-09-09 15:08:12 +00003337 // Skip conversion function templates; they don't tell us anything
Douglas Gregor05155d82009-08-21 23:19:43 +00003338 // about which builtin types we can convert to.
John McCalld14a8642009-11-21 08:51:07 +00003339 if (isa<FunctionTemplateDecl>(*I))
Douglas Gregor05155d82009-08-21 23:19:43 +00003340 continue;
3341
John McCalld14a8642009-11-21 08:51:07 +00003342 CXXConversionDecl *Conv = cast<CXXConversionDecl>(*I);
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00003343 if (AllowExplicitConversions || !Conv->isExplicit()) {
Douglas Gregorc02cfe22009-10-21 23:19:44 +00003344 AddTypesConvertedFrom(Conv->getConversionType(), Loc, false, false,
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00003345 VisibleQuals);
3346 }
Douglas Gregora11693b2008-11-12 17:17:38 +00003347 }
3348 }
3349 }
3350}
3351
Douglas Gregor84605ae2009-08-24 13:43:27 +00003352/// \brief Helper function for AddBuiltinOperatorCandidates() that adds
3353/// the volatile- and non-volatile-qualified assignment operators for the
3354/// given type to the candidate set.
3355static void AddBuiltinAssignmentOperatorCandidates(Sema &S,
3356 QualType T,
Mike Stump11289f42009-09-09 15:08:12 +00003357 Expr **Args,
Douglas Gregor84605ae2009-08-24 13:43:27 +00003358 unsigned NumArgs,
3359 OverloadCandidateSet &CandidateSet) {
3360 QualType ParamTypes[2];
Mike Stump11289f42009-09-09 15:08:12 +00003361
Douglas Gregor84605ae2009-08-24 13:43:27 +00003362 // T& operator=(T&, T)
3363 ParamTypes[0] = S.Context.getLValueReferenceType(T);
3364 ParamTypes[1] = T;
3365 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
3366 /*IsAssignmentOperator=*/true);
Mike Stump11289f42009-09-09 15:08:12 +00003367
Douglas Gregor84605ae2009-08-24 13:43:27 +00003368 if (!S.Context.getCanonicalType(T).isVolatileQualified()) {
3369 // volatile T& operator=(volatile T&, T)
John McCall8ccfcb52009-09-24 19:53:00 +00003370 ParamTypes[0]
3371 = S.Context.getLValueReferenceType(S.Context.getVolatileType(T));
Douglas Gregor84605ae2009-08-24 13:43:27 +00003372 ParamTypes[1] = T;
3373 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
Mike Stump11289f42009-09-09 15:08:12 +00003374 /*IsAssignmentOperator=*/true);
Douglas Gregor84605ae2009-08-24 13:43:27 +00003375 }
3376}
Mike Stump11289f42009-09-09 15:08:12 +00003377
Sebastian Redl1054fae2009-10-25 17:03:50 +00003378/// CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers,
3379/// if any, found in visible type conversion functions found in ArgExpr's type.
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00003380static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) {
3381 Qualifiers VRQuals;
3382 const RecordType *TyRec;
3383 if (const MemberPointerType *RHSMPType =
3384 ArgExpr->getType()->getAs<MemberPointerType>())
3385 TyRec = cast<RecordType>(RHSMPType->getClass());
3386 else
3387 TyRec = ArgExpr->getType()->getAs<RecordType>();
3388 if (!TyRec) {
Fariborz Jahanianb06ec052009-10-16 22:08:05 +00003389 // Just to be safe, assume the worst case.
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00003390 VRQuals.addVolatile();
3391 VRQuals.addRestrict();
3392 return VRQuals;
3393 }
3394
3395 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
John McCall67da35c2010-02-04 22:26:26 +00003396 if (!ClassDecl->hasDefinition())
3397 return VRQuals;
3398
John McCallad371252010-01-20 00:46:10 +00003399 const UnresolvedSetImpl *Conversions =
Sebastian Redl1054fae2009-10-25 17:03:50 +00003400 ClassDecl->getVisibleConversionFunctions();
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00003401
John McCallad371252010-01-20 00:46:10 +00003402 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
John McCalld14a8642009-11-21 08:51:07 +00003403 E = Conversions->end(); I != E; ++I) {
3404 if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(*I)) {
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00003405 QualType CanTy = Context.getCanonicalType(Conv->getConversionType());
3406 if (const ReferenceType *ResTypeRef = CanTy->getAs<ReferenceType>())
3407 CanTy = ResTypeRef->getPointeeType();
3408 // Need to go down the pointer/mempointer chain and add qualifiers
3409 // as see them.
3410 bool done = false;
3411 while (!done) {
3412 if (const PointerType *ResTypePtr = CanTy->getAs<PointerType>())
3413 CanTy = ResTypePtr->getPointeeType();
3414 else if (const MemberPointerType *ResTypeMPtr =
3415 CanTy->getAs<MemberPointerType>())
3416 CanTy = ResTypeMPtr->getPointeeType();
3417 else
3418 done = true;
3419 if (CanTy.isVolatileQualified())
3420 VRQuals.addVolatile();
3421 if (CanTy.isRestrictQualified())
3422 VRQuals.addRestrict();
3423 if (VRQuals.hasRestrict() && VRQuals.hasVolatile())
3424 return VRQuals;
3425 }
3426 }
3427 }
3428 return VRQuals;
3429}
3430
Douglas Gregord08452f2008-11-19 15:42:04 +00003431/// AddBuiltinOperatorCandidates - Add the appropriate built-in
3432/// operator overloads to the candidate set (C++ [over.built]), based
3433/// on the operator @p Op and the arguments given. For example, if the
3434/// operator is a binary '+', this routine might add "int
3435/// operator+(int, int)" to cover integer addition.
Douglas Gregora11693b2008-11-12 17:17:38 +00003436void
Mike Stump11289f42009-09-09 15:08:12 +00003437Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
Douglas Gregorc02cfe22009-10-21 23:19:44 +00003438 SourceLocation OpLoc,
Douglas Gregord08452f2008-11-19 15:42:04 +00003439 Expr **Args, unsigned NumArgs,
3440 OverloadCandidateSet& CandidateSet) {
Douglas Gregora11693b2008-11-12 17:17:38 +00003441 // The set of "promoted arithmetic types", which are the arithmetic
3442 // types are that preserved by promotion (C++ [over.built]p2). Note
3443 // that the first few of these types are the promoted integral
3444 // types; these types need to be first.
3445 // FIXME: What about complex?
3446 const unsigned FirstIntegralType = 0;
3447 const unsigned LastIntegralType = 13;
Mike Stump11289f42009-09-09 15:08:12 +00003448 const unsigned FirstPromotedIntegralType = 7,
Douglas Gregora11693b2008-11-12 17:17:38 +00003449 LastPromotedIntegralType = 13;
3450 const unsigned FirstPromotedArithmeticType = 7,
3451 LastPromotedArithmeticType = 16;
3452 const unsigned NumArithmeticTypes = 16;
3453 QualType ArithmeticTypes[NumArithmeticTypes] = {
Mike Stump11289f42009-09-09 15:08:12 +00003454 Context.BoolTy, Context.CharTy, Context.WCharTy,
3455// FIXME: Context.Char16Ty, Context.Char32Ty,
Douglas Gregora11693b2008-11-12 17:17:38 +00003456 Context.SignedCharTy, Context.ShortTy,
3457 Context.UnsignedCharTy, Context.UnsignedShortTy,
3458 Context.IntTy, Context.LongTy, Context.LongLongTy,
3459 Context.UnsignedIntTy, Context.UnsignedLongTy, Context.UnsignedLongLongTy,
3460 Context.FloatTy, Context.DoubleTy, Context.LongDoubleTy
3461 };
Douglas Gregorb8440a72009-10-21 22:01:30 +00003462 assert(ArithmeticTypes[FirstPromotedIntegralType] == Context.IntTy &&
3463 "Invalid first promoted integral type");
3464 assert(ArithmeticTypes[LastPromotedIntegralType - 1]
3465 == Context.UnsignedLongLongTy &&
3466 "Invalid last promoted integral type");
3467 assert(ArithmeticTypes[FirstPromotedArithmeticType] == Context.IntTy &&
3468 "Invalid first promoted arithmetic type");
3469 assert(ArithmeticTypes[LastPromotedArithmeticType - 1]
3470 == Context.LongDoubleTy &&
3471 "Invalid last promoted arithmetic type");
3472
Douglas Gregora11693b2008-11-12 17:17:38 +00003473 // Find all of the types that the arguments can convert to, but only
3474 // if the operator we're looking at has built-in operator candidates
3475 // that make use of these types.
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00003476 Qualifiers VisibleTypeConversionsQuals;
3477 VisibleTypeConversionsQuals.addConst();
Fariborz Jahanianb9e8c422009-10-19 21:30:45 +00003478 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx)
3479 VisibleTypeConversionsQuals += CollectVRQualifiers(Context, Args[ArgIdx]);
3480
Douglas Gregor8a2e6012009-08-24 15:23:48 +00003481 BuiltinCandidateTypeSet CandidateTypes(*this);
Douglas Gregora11693b2008-11-12 17:17:38 +00003482 if (Op == OO_Less || Op == OO_Greater || Op == OO_LessEqual ||
3483 Op == OO_GreaterEqual || Op == OO_EqualEqual || Op == OO_ExclaimEqual ||
Douglas Gregord08452f2008-11-19 15:42:04 +00003484 Op == OO_Plus || (Op == OO_Minus && NumArgs == 2) || Op == OO_Equal ||
Douglas Gregora11693b2008-11-12 17:17:38 +00003485 Op == OO_PlusEqual || Op == OO_MinusEqual || Op == OO_Subscript ||
Douglas Gregord08452f2008-11-19 15:42:04 +00003486 Op == OO_ArrowStar || Op == OO_PlusPlus || Op == OO_MinusMinus ||
Sebastian Redl1a99f442009-04-16 17:51:27 +00003487 (Op == OO_Star && NumArgs == 1) || Op == OO_Conditional) {
Douglas Gregord08452f2008-11-19 15:42:04 +00003488 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx)
Douglas Gregor5fb53972009-01-14 15:45:31 +00003489 CandidateTypes.AddTypesConvertedFrom(Args[ArgIdx]->getType(),
Douglas Gregorc02cfe22009-10-21 23:19:44 +00003490 OpLoc,
Douglas Gregor5fb53972009-01-14 15:45:31 +00003491 true,
3492 (Op == OO_Exclaim ||
3493 Op == OO_AmpAmp ||
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00003494 Op == OO_PipePipe),
3495 VisibleTypeConversionsQuals);
Douglas Gregora11693b2008-11-12 17:17:38 +00003496 }
3497
3498 bool isComparison = false;
3499 switch (Op) {
3500 case OO_None:
3501 case NUM_OVERLOADED_OPERATORS:
3502 assert(false && "Expected an overloaded operator");
3503 break;
3504
Douglas Gregord08452f2008-11-19 15:42:04 +00003505 case OO_Star: // '*' is either unary or binary
Mike Stump11289f42009-09-09 15:08:12 +00003506 if (NumArgs == 1)
Douglas Gregord08452f2008-11-19 15:42:04 +00003507 goto UnaryStar;
3508 else
3509 goto BinaryStar;
3510 break;
3511
3512 case OO_Plus: // '+' is either unary or binary
3513 if (NumArgs == 1)
3514 goto UnaryPlus;
3515 else
3516 goto BinaryPlus;
3517 break;
3518
3519 case OO_Minus: // '-' is either unary or binary
3520 if (NumArgs == 1)
3521 goto UnaryMinus;
3522 else
3523 goto BinaryMinus;
3524 break;
3525
3526 case OO_Amp: // '&' is either unary or binary
3527 if (NumArgs == 1)
3528 goto UnaryAmp;
3529 else
3530 goto BinaryAmp;
3531
3532 case OO_PlusPlus:
3533 case OO_MinusMinus:
3534 // C++ [over.built]p3:
3535 //
3536 // For every pair (T, VQ), where T is an arithmetic type, and VQ
3537 // is either volatile or empty, there exist candidate operator
3538 // functions of the form
3539 //
3540 // VQ T& operator++(VQ T&);
3541 // T operator++(VQ T&, int);
3542 //
3543 // C++ [over.built]p4:
3544 //
3545 // For every pair (T, VQ), where T is an arithmetic type other
3546 // than bool, and VQ is either volatile or empty, there exist
3547 // candidate operator functions of the form
3548 //
3549 // VQ T& operator--(VQ T&);
3550 // T operator--(VQ T&, int);
Mike Stump11289f42009-09-09 15:08:12 +00003551 for (unsigned Arith = (Op == OO_PlusPlus? 0 : 1);
Douglas Gregord08452f2008-11-19 15:42:04 +00003552 Arith < NumArithmeticTypes; ++Arith) {
3553 QualType ArithTy = ArithmeticTypes[Arith];
Mike Stump11289f42009-09-09 15:08:12 +00003554 QualType ParamTypes[2]
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00003555 = { Context.getLValueReferenceType(ArithTy), Context.IntTy };
Douglas Gregord08452f2008-11-19 15:42:04 +00003556
3557 // Non-volatile version.
3558 if (NumArgs == 1)
3559 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 1, CandidateSet);
3560 else
3561 AddBuiltinCandidate(ArithTy, ParamTypes, Args, 2, CandidateSet);
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00003562 // heuristic to reduce number of builtin candidates in the set.
3563 // Add volatile version only if there are conversions to a volatile type.
3564 if (VisibleTypeConversionsQuals.hasVolatile()) {
3565 // Volatile version
3566 ParamTypes[0]
3567 = Context.getLValueReferenceType(Context.getVolatileType(ArithTy));
3568 if (NumArgs == 1)
3569 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 1, CandidateSet);
3570 else
3571 AddBuiltinCandidate(ArithTy, ParamTypes, Args, 2, CandidateSet);
3572 }
Douglas Gregord08452f2008-11-19 15:42:04 +00003573 }
3574
3575 // C++ [over.built]p5:
3576 //
3577 // For every pair (T, VQ), where T is a cv-qualified or
3578 // cv-unqualified object type, and VQ is either volatile or
3579 // empty, there exist candidate operator functions of the form
3580 //
3581 // T*VQ& operator++(T*VQ&);
3582 // T*VQ& operator--(T*VQ&);
3583 // T* operator++(T*VQ&, int);
3584 // T* operator--(T*VQ&, int);
3585 for (BuiltinCandidateTypeSet::iterator Ptr = CandidateTypes.pointer_begin();
3586 Ptr != CandidateTypes.pointer_end(); ++Ptr) {
3587 // Skip pointer types that aren't pointers to object types.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003588 if (!(*Ptr)->getAs<PointerType>()->getPointeeType()->isObjectType())
Douglas Gregord08452f2008-11-19 15:42:04 +00003589 continue;
3590
Mike Stump11289f42009-09-09 15:08:12 +00003591 QualType ParamTypes[2] = {
3592 Context.getLValueReferenceType(*Ptr), Context.IntTy
Douglas Gregord08452f2008-11-19 15:42:04 +00003593 };
Mike Stump11289f42009-09-09 15:08:12 +00003594
Douglas Gregord08452f2008-11-19 15:42:04 +00003595 // Without volatile
3596 if (NumArgs == 1)
3597 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 1, CandidateSet);
3598 else
3599 AddBuiltinCandidate(*Ptr, ParamTypes, Args, 2, CandidateSet);
3600
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00003601 if (!Context.getCanonicalType(*Ptr).isVolatileQualified() &&
3602 VisibleTypeConversionsQuals.hasVolatile()) {
Douglas Gregord08452f2008-11-19 15:42:04 +00003603 // With volatile
John McCall8ccfcb52009-09-24 19:53:00 +00003604 ParamTypes[0]
3605 = Context.getLValueReferenceType(Context.getVolatileType(*Ptr));
Douglas Gregord08452f2008-11-19 15:42:04 +00003606 if (NumArgs == 1)
3607 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 1, CandidateSet);
3608 else
3609 AddBuiltinCandidate(*Ptr, ParamTypes, Args, 2, CandidateSet);
3610 }
3611 }
3612 break;
3613
3614 UnaryStar:
3615 // C++ [over.built]p6:
3616 // For every cv-qualified or cv-unqualified object type T, there
3617 // exist candidate operator functions of the form
3618 //
3619 // T& operator*(T*);
3620 //
3621 // C++ [over.built]p7:
3622 // For every function type T, there exist candidate operator
3623 // functions of the form
3624 // T& operator*(T*);
3625 for (BuiltinCandidateTypeSet::iterator Ptr = CandidateTypes.pointer_begin();
3626 Ptr != CandidateTypes.pointer_end(); ++Ptr) {
3627 QualType ParamTy = *Ptr;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003628 QualType PointeeTy = ParamTy->getAs<PointerType>()->getPointeeType();
Mike Stump11289f42009-09-09 15:08:12 +00003629 AddBuiltinCandidate(Context.getLValueReferenceType(PointeeTy),
Douglas Gregord08452f2008-11-19 15:42:04 +00003630 &ParamTy, Args, 1, CandidateSet);
3631 }
3632 break;
3633
3634 UnaryPlus:
3635 // C++ [over.built]p8:
3636 // For every type T, there exist candidate operator functions of
3637 // the form
3638 //
3639 // T* operator+(T*);
3640 for (BuiltinCandidateTypeSet::iterator Ptr = CandidateTypes.pointer_begin();
3641 Ptr != CandidateTypes.pointer_end(); ++Ptr) {
3642 QualType ParamTy = *Ptr;
3643 AddBuiltinCandidate(ParamTy, &ParamTy, Args, 1, CandidateSet);
3644 }
Mike Stump11289f42009-09-09 15:08:12 +00003645
Douglas Gregord08452f2008-11-19 15:42:04 +00003646 // Fall through
3647
3648 UnaryMinus:
3649 // C++ [over.built]p9:
3650 // For every promoted arithmetic type T, there exist candidate
3651 // operator functions of the form
3652 //
3653 // T operator+(T);
3654 // T operator-(T);
Mike Stump11289f42009-09-09 15:08:12 +00003655 for (unsigned Arith = FirstPromotedArithmeticType;
Douglas Gregord08452f2008-11-19 15:42:04 +00003656 Arith < LastPromotedArithmeticType; ++Arith) {
3657 QualType ArithTy = ArithmeticTypes[Arith];
3658 AddBuiltinCandidate(ArithTy, &ArithTy, Args, 1, CandidateSet);
3659 }
3660 break;
3661
3662 case OO_Tilde:
3663 // C++ [over.built]p10:
3664 // For every promoted integral type T, there exist candidate
3665 // operator functions of the form
3666 //
3667 // T operator~(T);
Mike Stump11289f42009-09-09 15:08:12 +00003668 for (unsigned Int = FirstPromotedIntegralType;
Douglas Gregord08452f2008-11-19 15:42:04 +00003669 Int < LastPromotedIntegralType; ++Int) {
3670 QualType IntTy = ArithmeticTypes[Int];
3671 AddBuiltinCandidate(IntTy, &IntTy, Args, 1, CandidateSet);
3672 }
3673 break;
3674
Douglas Gregora11693b2008-11-12 17:17:38 +00003675 case OO_New:
3676 case OO_Delete:
3677 case OO_Array_New:
3678 case OO_Array_Delete:
Douglas Gregora11693b2008-11-12 17:17:38 +00003679 case OO_Call:
Douglas Gregord08452f2008-11-19 15:42:04 +00003680 assert(false && "Special operators don't use AddBuiltinOperatorCandidates");
Douglas Gregora11693b2008-11-12 17:17:38 +00003681 break;
3682
3683 case OO_Comma:
Douglas Gregord08452f2008-11-19 15:42:04 +00003684 UnaryAmp:
3685 case OO_Arrow:
Douglas Gregora11693b2008-11-12 17:17:38 +00003686 // C++ [over.match.oper]p3:
3687 // -- For the operator ',', the unary operator '&', or the
3688 // operator '->', the built-in candidates set is empty.
Douglas Gregora11693b2008-11-12 17:17:38 +00003689 break;
3690
Douglas Gregor84605ae2009-08-24 13:43:27 +00003691 case OO_EqualEqual:
3692 case OO_ExclaimEqual:
3693 // C++ [over.match.oper]p16:
Mike Stump11289f42009-09-09 15:08:12 +00003694 // For every pointer to member type T, there exist candidate operator
3695 // functions of the form
Douglas Gregor84605ae2009-08-24 13:43:27 +00003696 //
3697 // bool operator==(T,T);
3698 // bool operator!=(T,T);
Mike Stump11289f42009-09-09 15:08:12 +00003699 for (BuiltinCandidateTypeSet::iterator
Douglas Gregor84605ae2009-08-24 13:43:27 +00003700 MemPtr = CandidateTypes.member_pointer_begin(),
3701 MemPtrEnd = CandidateTypes.member_pointer_end();
3702 MemPtr != MemPtrEnd;
3703 ++MemPtr) {
3704 QualType ParamTypes[2] = { *MemPtr, *MemPtr };
3705 AddBuiltinCandidate(Context.BoolTy, ParamTypes, Args, 2, CandidateSet);
3706 }
Mike Stump11289f42009-09-09 15:08:12 +00003707
Douglas Gregor84605ae2009-08-24 13:43:27 +00003708 // Fall through
Mike Stump11289f42009-09-09 15:08:12 +00003709
Douglas Gregora11693b2008-11-12 17:17:38 +00003710 case OO_Less:
3711 case OO_Greater:
3712 case OO_LessEqual:
3713 case OO_GreaterEqual:
Douglas Gregora11693b2008-11-12 17:17:38 +00003714 // C++ [over.built]p15:
3715 //
3716 // For every pointer or enumeration type T, there exist
3717 // candidate operator functions of the form
Mike Stump11289f42009-09-09 15:08:12 +00003718 //
Douglas Gregora11693b2008-11-12 17:17:38 +00003719 // bool operator<(T, T);
3720 // bool operator>(T, T);
3721 // bool operator<=(T, T);
3722 // bool operator>=(T, T);
3723 // bool operator==(T, T);
3724 // bool operator!=(T, T);
3725 for (BuiltinCandidateTypeSet::iterator Ptr = CandidateTypes.pointer_begin();
3726 Ptr != CandidateTypes.pointer_end(); ++Ptr) {
3727 QualType ParamTypes[2] = { *Ptr, *Ptr };
3728 AddBuiltinCandidate(Context.BoolTy, ParamTypes, Args, 2, CandidateSet);
3729 }
Mike Stump11289f42009-09-09 15:08:12 +00003730 for (BuiltinCandidateTypeSet::iterator Enum
Douglas Gregora11693b2008-11-12 17:17:38 +00003731 = CandidateTypes.enumeration_begin();
3732 Enum != CandidateTypes.enumeration_end(); ++Enum) {
3733 QualType ParamTypes[2] = { *Enum, *Enum };
3734 AddBuiltinCandidate(Context.BoolTy, ParamTypes, Args, 2, CandidateSet);
3735 }
3736
3737 // Fall through.
3738 isComparison = true;
3739
Douglas Gregord08452f2008-11-19 15:42:04 +00003740 BinaryPlus:
3741 BinaryMinus:
Douglas Gregora11693b2008-11-12 17:17:38 +00003742 if (!isComparison) {
3743 // We didn't fall through, so we must have OO_Plus or OO_Minus.
3744
3745 // C++ [over.built]p13:
3746 //
3747 // For every cv-qualified or cv-unqualified object type T
3748 // there exist candidate operator functions of the form
Mike Stump11289f42009-09-09 15:08:12 +00003749 //
Douglas Gregora11693b2008-11-12 17:17:38 +00003750 // T* operator+(T*, ptrdiff_t);
3751 // T& operator[](T*, ptrdiff_t); [BELOW]
3752 // T* operator-(T*, ptrdiff_t);
3753 // T* operator+(ptrdiff_t, T*);
3754 // T& operator[](ptrdiff_t, T*); [BELOW]
3755 //
3756 // C++ [over.built]p14:
3757 //
3758 // For every T, where T is a pointer to object type, there
3759 // exist candidate operator functions of the form
3760 //
3761 // ptrdiff_t operator-(T, T);
Mike Stump11289f42009-09-09 15:08:12 +00003762 for (BuiltinCandidateTypeSet::iterator Ptr
Douglas Gregora11693b2008-11-12 17:17:38 +00003763 = CandidateTypes.pointer_begin();
3764 Ptr != CandidateTypes.pointer_end(); ++Ptr) {
3765 QualType ParamTypes[2] = { *Ptr, Context.getPointerDiffType() };
3766
3767 // operator+(T*, ptrdiff_t) or operator-(T*, ptrdiff_t)
3768 AddBuiltinCandidate(*Ptr, ParamTypes, Args, 2, CandidateSet);
3769
3770 if (Op == OO_Plus) {
3771 // T* operator+(ptrdiff_t, T*);
3772 ParamTypes[0] = ParamTypes[1];
3773 ParamTypes[1] = *Ptr;
3774 AddBuiltinCandidate(*Ptr, ParamTypes, Args, 2, CandidateSet);
3775 } else {
3776 // ptrdiff_t operator-(T, T);
3777 ParamTypes[1] = *Ptr;
3778 AddBuiltinCandidate(Context.getPointerDiffType(), ParamTypes,
3779 Args, 2, CandidateSet);
3780 }
3781 }
3782 }
3783 // Fall through
3784
Douglas Gregora11693b2008-11-12 17:17:38 +00003785 case OO_Slash:
Douglas Gregord08452f2008-11-19 15:42:04 +00003786 BinaryStar:
Sebastian Redl1a99f442009-04-16 17:51:27 +00003787 Conditional:
Douglas Gregora11693b2008-11-12 17:17:38 +00003788 // C++ [over.built]p12:
3789 //
3790 // For every pair of promoted arithmetic types L and R, there
3791 // exist candidate operator functions of the form
3792 //
3793 // LR operator*(L, R);
3794 // LR operator/(L, R);
3795 // LR operator+(L, R);
3796 // LR operator-(L, R);
3797 // bool operator<(L, R);
3798 // bool operator>(L, R);
3799 // bool operator<=(L, R);
3800 // bool operator>=(L, R);
3801 // bool operator==(L, R);
3802 // bool operator!=(L, R);
3803 //
3804 // where LR is the result of the usual arithmetic conversions
3805 // between types L and R.
Sebastian Redl1a99f442009-04-16 17:51:27 +00003806 //
3807 // C++ [over.built]p24:
3808 //
3809 // For every pair of promoted arithmetic types L and R, there exist
3810 // candidate operator functions of the form
3811 //
3812 // LR operator?(bool, L, R);
3813 //
3814 // where LR is the result of the usual arithmetic conversions
3815 // between types L and R.
3816 // Our candidates ignore the first parameter.
Mike Stump11289f42009-09-09 15:08:12 +00003817 for (unsigned Left = FirstPromotedArithmeticType;
Douglas Gregora11693b2008-11-12 17:17:38 +00003818 Left < LastPromotedArithmeticType; ++Left) {
Mike Stump11289f42009-09-09 15:08:12 +00003819 for (unsigned Right = FirstPromotedArithmeticType;
Douglas Gregora11693b2008-11-12 17:17:38 +00003820 Right < LastPromotedArithmeticType; ++Right) {
3821 QualType LandR[2] = { ArithmeticTypes[Left], ArithmeticTypes[Right] };
Eli Friedman5ae98ee2009-08-19 07:44:53 +00003822 QualType Result
3823 = isComparison
3824 ? Context.BoolTy
3825 : Context.UsualArithmeticConversionsType(LandR[0], LandR[1]);
Douglas Gregora11693b2008-11-12 17:17:38 +00003826 AddBuiltinCandidate(Result, LandR, Args, 2, CandidateSet);
3827 }
3828 }
3829 break;
3830
3831 case OO_Percent:
Douglas Gregord08452f2008-11-19 15:42:04 +00003832 BinaryAmp:
Douglas Gregora11693b2008-11-12 17:17:38 +00003833 case OO_Caret:
3834 case OO_Pipe:
3835 case OO_LessLess:
3836 case OO_GreaterGreater:
3837 // C++ [over.built]p17:
3838 //
3839 // For every pair of promoted integral types L and R, there
3840 // exist candidate operator functions of the form
3841 //
3842 // LR operator%(L, R);
3843 // LR operator&(L, R);
3844 // LR operator^(L, R);
3845 // LR operator|(L, R);
3846 // L operator<<(L, R);
3847 // L operator>>(L, R);
3848 //
3849 // where LR is the result of the usual arithmetic conversions
3850 // between types L and R.
Mike Stump11289f42009-09-09 15:08:12 +00003851 for (unsigned Left = FirstPromotedIntegralType;
Douglas Gregora11693b2008-11-12 17:17:38 +00003852 Left < LastPromotedIntegralType; ++Left) {
Mike Stump11289f42009-09-09 15:08:12 +00003853 for (unsigned Right = FirstPromotedIntegralType;
Douglas Gregora11693b2008-11-12 17:17:38 +00003854 Right < LastPromotedIntegralType; ++Right) {
3855 QualType LandR[2] = { ArithmeticTypes[Left], ArithmeticTypes[Right] };
3856 QualType Result = (Op == OO_LessLess || Op == OO_GreaterGreater)
3857 ? LandR[0]
Eli Friedman5ae98ee2009-08-19 07:44:53 +00003858 : Context.UsualArithmeticConversionsType(LandR[0], LandR[1]);
Douglas Gregora11693b2008-11-12 17:17:38 +00003859 AddBuiltinCandidate(Result, LandR, Args, 2, CandidateSet);
3860 }
3861 }
3862 break;
3863
3864 case OO_Equal:
3865 // C++ [over.built]p20:
3866 //
3867 // For every pair (T, VQ), where T is an enumeration or
Douglas Gregor84605ae2009-08-24 13:43:27 +00003868 // pointer to member type and VQ is either volatile or
Douglas Gregora11693b2008-11-12 17:17:38 +00003869 // empty, there exist candidate operator functions of the form
3870 //
3871 // VQ T& operator=(VQ T&, T);
Douglas Gregor84605ae2009-08-24 13:43:27 +00003872 for (BuiltinCandidateTypeSet::iterator
3873 Enum = CandidateTypes.enumeration_begin(),
3874 EnumEnd = CandidateTypes.enumeration_end();
3875 Enum != EnumEnd; ++Enum)
Mike Stump11289f42009-09-09 15:08:12 +00003876 AddBuiltinAssignmentOperatorCandidates(*this, *Enum, Args, 2,
Douglas Gregor84605ae2009-08-24 13:43:27 +00003877 CandidateSet);
3878 for (BuiltinCandidateTypeSet::iterator
3879 MemPtr = CandidateTypes.member_pointer_begin(),
3880 MemPtrEnd = CandidateTypes.member_pointer_end();
3881 MemPtr != MemPtrEnd; ++MemPtr)
Mike Stump11289f42009-09-09 15:08:12 +00003882 AddBuiltinAssignmentOperatorCandidates(*this, *MemPtr, Args, 2,
Douglas Gregor84605ae2009-08-24 13:43:27 +00003883 CandidateSet);
3884 // Fall through.
Douglas Gregora11693b2008-11-12 17:17:38 +00003885
3886 case OO_PlusEqual:
3887 case OO_MinusEqual:
3888 // C++ [over.built]p19:
3889 //
3890 // For every pair (T, VQ), where T is any type and VQ is either
3891 // volatile or empty, there exist candidate operator functions
3892 // of the form
3893 //
3894 // T*VQ& operator=(T*VQ&, T*);
3895 //
3896 // C++ [over.built]p21:
3897 //
3898 // For every pair (T, VQ), where T is a cv-qualified or
3899 // cv-unqualified object type and VQ is either volatile or
3900 // empty, there exist candidate operator functions of the form
3901 //
3902 // T*VQ& operator+=(T*VQ&, ptrdiff_t);
3903 // T*VQ& operator-=(T*VQ&, ptrdiff_t);
3904 for (BuiltinCandidateTypeSet::iterator Ptr = CandidateTypes.pointer_begin();
3905 Ptr != CandidateTypes.pointer_end(); ++Ptr) {
3906 QualType ParamTypes[2];
3907 ParamTypes[1] = (Op == OO_Equal)? *Ptr : Context.getPointerDiffType();
3908
3909 // non-volatile version
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00003910 ParamTypes[0] = Context.getLValueReferenceType(*Ptr);
Douglas Gregorc5e61072009-01-13 00:52:54 +00003911 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
3912 /*IsAssigmentOperator=*/Op == OO_Equal);
Douglas Gregora11693b2008-11-12 17:17:38 +00003913
Fariborz Jahanianb9e8c422009-10-19 21:30:45 +00003914 if (!Context.getCanonicalType(*Ptr).isVolatileQualified() &&
3915 VisibleTypeConversionsQuals.hasVolatile()) {
Douglas Gregord08452f2008-11-19 15:42:04 +00003916 // volatile version
John McCall8ccfcb52009-09-24 19:53:00 +00003917 ParamTypes[0]
3918 = Context.getLValueReferenceType(Context.getVolatileType(*Ptr));
Douglas Gregorc5e61072009-01-13 00:52:54 +00003919 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
3920 /*IsAssigmentOperator=*/Op == OO_Equal);
Douglas Gregord08452f2008-11-19 15:42:04 +00003921 }
Douglas Gregora11693b2008-11-12 17:17:38 +00003922 }
3923 // Fall through.
3924
3925 case OO_StarEqual:
3926 case OO_SlashEqual:
3927 // C++ [over.built]p18:
3928 //
3929 // For every triple (L, VQ, R), where L is an arithmetic type,
3930 // VQ is either volatile or empty, and R is a promoted
3931 // arithmetic type, there exist candidate operator functions of
3932 // the form
3933 //
3934 // VQ L& operator=(VQ L&, R);
3935 // VQ L& operator*=(VQ L&, R);
3936 // VQ L& operator/=(VQ L&, R);
3937 // VQ L& operator+=(VQ L&, R);
3938 // VQ L& operator-=(VQ L&, R);
3939 for (unsigned Left = 0; Left < NumArithmeticTypes; ++Left) {
Mike Stump11289f42009-09-09 15:08:12 +00003940 for (unsigned Right = FirstPromotedArithmeticType;
Douglas Gregora11693b2008-11-12 17:17:38 +00003941 Right < LastPromotedArithmeticType; ++Right) {
3942 QualType ParamTypes[2];
3943 ParamTypes[1] = ArithmeticTypes[Right];
3944
3945 // Add this built-in operator as a candidate (VQ is empty).
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00003946 ParamTypes[0] = Context.getLValueReferenceType(ArithmeticTypes[Left]);
Douglas Gregorc5e61072009-01-13 00:52:54 +00003947 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
3948 /*IsAssigmentOperator=*/Op == OO_Equal);
Douglas Gregora11693b2008-11-12 17:17:38 +00003949
3950 // Add this built-in operator as a candidate (VQ is 'volatile').
Fariborz Jahanianb9e8c422009-10-19 21:30:45 +00003951 if (VisibleTypeConversionsQuals.hasVolatile()) {
3952 ParamTypes[0] = Context.getVolatileType(ArithmeticTypes[Left]);
3953 ParamTypes[0] = Context.getLValueReferenceType(ParamTypes[0]);
3954 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
3955 /*IsAssigmentOperator=*/Op == OO_Equal);
3956 }
Douglas Gregora11693b2008-11-12 17:17:38 +00003957 }
3958 }
3959 break;
3960
3961 case OO_PercentEqual:
3962 case OO_LessLessEqual:
3963 case OO_GreaterGreaterEqual:
3964 case OO_AmpEqual:
3965 case OO_CaretEqual:
3966 case OO_PipeEqual:
3967 // C++ [over.built]p22:
3968 //
3969 // For every triple (L, VQ, R), where L is an integral type, VQ
3970 // is either volatile or empty, and R is a promoted integral
3971 // type, there exist candidate operator functions of the form
3972 //
3973 // VQ L& operator%=(VQ L&, R);
3974 // VQ L& operator<<=(VQ L&, R);
3975 // VQ L& operator>>=(VQ L&, R);
3976 // VQ L& operator&=(VQ L&, R);
3977 // VQ L& operator^=(VQ L&, R);
3978 // VQ L& operator|=(VQ L&, R);
3979 for (unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) {
Mike Stump11289f42009-09-09 15:08:12 +00003980 for (unsigned Right = FirstPromotedIntegralType;
Douglas Gregora11693b2008-11-12 17:17:38 +00003981 Right < LastPromotedIntegralType; ++Right) {
3982 QualType ParamTypes[2];
3983 ParamTypes[1] = ArithmeticTypes[Right];
3984
3985 // Add this built-in operator as a candidate (VQ is empty).
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00003986 ParamTypes[0] = Context.getLValueReferenceType(ArithmeticTypes[Left]);
Douglas Gregora11693b2008-11-12 17:17:38 +00003987 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet);
Fariborz Jahaniana4a93342009-10-20 00:04:40 +00003988 if (VisibleTypeConversionsQuals.hasVolatile()) {
3989 // Add this built-in operator as a candidate (VQ is 'volatile').
3990 ParamTypes[0] = ArithmeticTypes[Left];
3991 ParamTypes[0] = Context.getVolatileType(ParamTypes[0]);
3992 ParamTypes[0] = Context.getLValueReferenceType(ParamTypes[0]);
3993 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet);
3994 }
Douglas Gregora11693b2008-11-12 17:17:38 +00003995 }
3996 }
3997 break;
3998
Douglas Gregord08452f2008-11-19 15:42:04 +00003999 case OO_Exclaim: {
4000 // C++ [over.operator]p23:
4001 //
4002 // There also exist candidate operator functions of the form
4003 //
Mike Stump11289f42009-09-09 15:08:12 +00004004 // bool operator!(bool);
Douglas Gregord08452f2008-11-19 15:42:04 +00004005 // bool operator&&(bool, bool); [BELOW]
4006 // bool operator||(bool, bool); [BELOW]
4007 QualType ParamTy = Context.BoolTy;
Douglas Gregor5fb53972009-01-14 15:45:31 +00004008 AddBuiltinCandidate(ParamTy, &ParamTy, Args, 1, CandidateSet,
4009 /*IsAssignmentOperator=*/false,
4010 /*NumContextualBoolArguments=*/1);
Douglas Gregord08452f2008-11-19 15:42:04 +00004011 break;
4012 }
4013
Douglas Gregora11693b2008-11-12 17:17:38 +00004014 case OO_AmpAmp:
4015 case OO_PipePipe: {
4016 // C++ [over.operator]p23:
4017 //
4018 // There also exist candidate operator functions of the form
4019 //
Douglas Gregord08452f2008-11-19 15:42:04 +00004020 // bool operator!(bool); [ABOVE]
Douglas Gregora11693b2008-11-12 17:17:38 +00004021 // bool operator&&(bool, bool);
4022 // bool operator||(bool, bool);
4023 QualType ParamTypes[2] = { Context.BoolTy, Context.BoolTy };
Douglas Gregor5fb53972009-01-14 15:45:31 +00004024 AddBuiltinCandidate(Context.BoolTy, ParamTypes, Args, 2, CandidateSet,
4025 /*IsAssignmentOperator=*/false,
4026 /*NumContextualBoolArguments=*/2);
Douglas Gregora11693b2008-11-12 17:17:38 +00004027 break;
4028 }
4029
4030 case OO_Subscript:
4031 // C++ [over.built]p13:
4032 //
4033 // For every cv-qualified or cv-unqualified object type T there
4034 // exist candidate operator functions of the form
Mike Stump11289f42009-09-09 15:08:12 +00004035 //
Douglas Gregora11693b2008-11-12 17:17:38 +00004036 // T* operator+(T*, ptrdiff_t); [ABOVE]
4037 // T& operator[](T*, ptrdiff_t);
4038 // T* operator-(T*, ptrdiff_t); [ABOVE]
4039 // T* operator+(ptrdiff_t, T*); [ABOVE]
4040 // T& operator[](ptrdiff_t, T*);
4041 for (BuiltinCandidateTypeSet::iterator Ptr = CandidateTypes.pointer_begin();
4042 Ptr != CandidateTypes.pointer_end(); ++Ptr) {
4043 QualType ParamTypes[2] = { *Ptr, Context.getPointerDiffType() };
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004044 QualType PointeeType = (*Ptr)->getAs<PointerType>()->getPointeeType();
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00004045 QualType ResultTy = Context.getLValueReferenceType(PointeeType);
Douglas Gregora11693b2008-11-12 17:17:38 +00004046
4047 // T& operator[](T*, ptrdiff_t)
4048 AddBuiltinCandidate(ResultTy, ParamTypes, Args, 2, CandidateSet);
4049
4050 // T& operator[](ptrdiff_t, T*);
4051 ParamTypes[0] = ParamTypes[1];
4052 ParamTypes[1] = *Ptr;
4053 AddBuiltinCandidate(ResultTy, ParamTypes, Args, 2, CandidateSet);
4054 }
4055 break;
4056
4057 case OO_ArrowStar:
Fariborz Jahanian34d93dc2009-10-06 23:08:05 +00004058 // C++ [over.built]p11:
4059 // For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type,
4060 // C1 is the same type as C2 or is a derived class of C2, T is an object
4061 // type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
4062 // there exist candidate operator functions of the form
4063 // CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
4064 // where CV12 is the union of CV1 and CV2.
4065 {
4066 for (BuiltinCandidateTypeSet::iterator Ptr =
4067 CandidateTypes.pointer_begin();
4068 Ptr != CandidateTypes.pointer_end(); ++Ptr) {
4069 QualType C1Ty = (*Ptr);
4070 QualType C1;
Fariborz Jahanian4dc12462009-10-09 16:34:40 +00004071 QualifierCollector Q1;
Fariborz Jahanian34d93dc2009-10-06 23:08:05 +00004072 if (const PointerType *PointerTy = C1Ty->getAs<PointerType>()) {
Fariborz Jahanian4dc12462009-10-09 16:34:40 +00004073 C1 = QualType(Q1.strip(PointerTy->getPointeeType()), 0);
Fariborz Jahanian34d93dc2009-10-06 23:08:05 +00004074 if (!isa<RecordType>(C1))
4075 continue;
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00004076 // heuristic to reduce number of builtin candidates in the set.
4077 // Add volatile/restrict version only if there are conversions to a
4078 // volatile/restrict type.
4079 if (!VisibleTypeConversionsQuals.hasVolatile() && Q1.hasVolatile())
4080 continue;
4081 if (!VisibleTypeConversionsQuals.hasRestrict() && Q1.hasRestrict())
4082 continue;
Fariborz Jahanian34d93dc2009-10-06 23:08:05 +00004083 }
4084 for (BuiltinCandidateTypeSet::iterator
4085 MemPtr = CandidateTypes.member_pointer_begin(),
4086 MemPtrEnd = CandidateTypes.member_pointer_end();
4087 MemPtr != MemPtrEnd; ++MemPtr) {
4088 const MemberPointerType *mptr = cast<MemberPointerType>(*MemPtr);
4089 QualType C2 = QualType(mptr->getClass(), 0);
Fariborz Jahanian12df37c2009-10-07 16:56:50 +00004090 C2 = C2.getUnqualifiedType();
Fariborz Jahanian34d93dc2009-10-06 23:08:05 +00004091 if (C1 != C2 && !IsDerivedFrom(C1, C2))
4092 break;
4093 QualType ParamTypes[2] = { *Ptr, *MemPtr };
4094 // build CV12 T&
4095 QualType T = mptr->getPointeeType();
Fariborz Jahanian3b937fa2009-10-15 17:14:05 +00004096 if (!VisibleTypeConversionsQuals.hasVolatile() &&
4097 T.isVolatileQualified())
4098 continue;
4099 if (!VisibleTypeConversionsQuals.hasRestrict() &&
4100 T.isRestrictQualified())
4101 continue;
Fariborz Jahanian4dc12462009-10-09 16:34:40 +00004102 T = Q1.apply(T);
Fariborz Jahanian34d93dc2009-10-06 23:08:05 +00004103 QualType ResultTy = Context.getLValueReferenceType(T);
4104 AddBuiltinCandidate(ResultTy, ParamTypes, Args, 2, CandidateSet);
4105 }
4106 }
4107 }
Douglas Gregora11693b2008-11-12 17:17:38 +00004108 break;
Sebastian Redl1a99f442009-04-16 17:51:27 +00004109
4110 case OO_Conditional:
4111 // Note that we don't consider the first argument, since it has been
4112 // contextually converted to bool long ago. The candidates below are
4113 // therefore added as binary.
4114 //
4115 // C++ [over.built]p24:
4116 // For every type T, where T is a pointer or pointer-to-member type,
4117 // there exist candidate operator functions of the form
4118 //
4119 // T operator?(bool, T, T);
4120 //
Sebastian Redl1a99f442009-04-16 17:51:27 +00004121 for (BuiltinCandidateTypeSet::iterator Ptr = CandidateTypes.pointer_begin(),
4122 E = CandidateTypes.pointer_end(); Ptr != E; ++Ptr) {
4123 QualType ParamTypes[2] = { *Ptr, *Ptr };
4124 AddBuiltinCandidate(*Ptr, ParamTypes, Args, 2, CandidateSet);
4125 }
Sebastian Redl8ce189f2009-04-19 21:53:20 +00004126 for (BuiltinCandidateTypeSet::iterator Ptr =
4127 CandidateTypes.member_pointer_begin(),
4128 E = CandidateTypes.member_pointer_end(); Ptr != E; ++Ptr) {
4129 QualType ParamTypes[2] = { *Ptr, *Ptr };
4130 AddBuiltinCandidate(*Ptr, ParamTypes, Args, 2, CandidateSet);
4131 }
Sebastian Redl1a99f442009-04-16 17:51:27 +00004132 goto Conditional;
Douglas Gregora11693b2008-11-12 17:17:38 +00004133 }
4134}
4135
Douglas Gregore254f902009-02-04 00:32:51 +00004136/// \brief Add function candidates found via argument-dependent lookup
4137/// to the set of overloading candidates.
4138///
4139/// This routine performs argument-dependent name lookup based on the
4140/// given function name (which may also be an operator name) and adds
4141/// all of the overload candidates found by ADL to the overload
4142/// candidate set (C++ [basic.lookup.argdep]).
Mike Stump11289f42009-09-09 15:08:12 +00004143void
Douglas Gregore254f902009-02-04 00:32:51 +00004144Sema::AddArgumentDependentLookupCandidates(DeclarationName Name,
John McCall4c4c1df2010-01-26 03:27:55 +00004145 bool Operator,
Douglas Gregore254f902009-02-04 00:32:51 +00004146 Expr **Args, unsigned NumArgs,
John McCall6b51f282009-11-23 01:53:49 +00004147 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregorcabea402009-09-22 15:41:20 +00004148 OverloadCandidateSet& CandidateSet,
4149 bool PartialOverloading) {
John McCall8fe68082010-01-26 07:16:45 +00004150 ADLResult Fns;
Douglas Gregore254f902009-02-04 00:32:51 +00004151
John McCall91f61fc2010-01-26 06:04:06 +00004152 // FIXME: This approach for uniquing ADL results (and removing
4153 // redundant candidates from the set) relies on pointer-equality,
4154 // which means we need to key off the canonical decl. However,
4155 // always going back to the canonical decl might not get us the
4156 // right set of default arguments. What default arguments are
4157 // we supposed to consider on ADL candidates, anyway?
4158
Douglas Gregorcabea402009-09-22 15:41:20 +00004159 // FIXME: Pass in the explicit template arguments?
John McCall8fe68082010-01-26 07:16:45 +00004160 ArgumentDependentLookup(Name, Operator, Args, NumArgs, Fns);
Douglas Gregore254f902009-02-04 00:32:51 +00004161
Douglas Gregord2b7ef62009-03-13 00:33:25 +00004162 // Erase all of the candidates we already knew about.
Douglas Gregord2b7ef62009-03-13 00:33:25 +00004163 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
4164 CandEnd = CandidateSet.end();
4165 Cand != CandEnd; ++Cand)
Douglas Gregor15448f82009-06-27 21:05:07 +00004166 if (Cand->Function) {
John McCall8fe68082010-01-26 07:16:45 +00004167 Fns.erase(Cand->Function);
Douglas Gregor15448f82009-06-27 21:05:07 +00004168 if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate())
John McCall8fe68082010-01-26 07:16:45 +00004169 Fns.erase(FunTmpl);
Douglas Gregor15448f82009-06-27 21:05:07 +00004170 }
Douglas Gregord2b7ef62009-03-13 00:33:25 +00004171
4172 // For each of the ADL candidates we found, add it to the overload
4173 // set.
John McCall8fe68082010-01-26 07:16:45 +00004174 for (ADLResult::iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
John McCall4c4c1df2010-01-26 03:27:55 +00004175 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
John McCall6b51f282009-11-23 01:53:49 +00004176 if (ExplicitTemplateArgs)
Douglas Gregorcabea402009-09-22 15:41:20 +00004177 continue;
4178
John McCallb89836b2010-01-26 01:37:31 +00004179 AddOverloadCandidate(FD, AS_none, Args, NumArgs, CandidateSet,
Douglas Gregorcabea402009-09-22 15:41:20 +00004180 false, false, PartialOverloading);
4181 } else
John McCall4c4c1df2010-01-26 03:27:55 +00004182 AddTemplateOverloadCandidate(cast<FunctionTemplateDecl>(*I),
John McCallb89836b2010-01-26 01:37:31 +00004183 AS_none, ExplicitTemplateArgs,
Douglas Gregor89026b52009-06-30 23:57:56 +00004184 Args, NumArgs, CandidateSet);
Douglas Gregor15448f82009-06-27 21:05:07 +00004185 }
Douglas Gregore254f902009-02-04 00:32:51 +00004186}
4187
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004188/// isBetterOverloadCandidate - Determines whether the first overload
4189/// candidate is a better candidate than the second (C++ 13.3.3p1).
Mike Stump11289f42009-09-09 15:08:12 +00004190bool
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004191Sema::isBetterOverloadCandidate(const OverloadCandidate& Cand1,
John McCallbc077cf2010-02-08 23:07:23 +00004192 const OverloadCandidate& Cand2,
4193 SourceLocation Loc) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004194 // Define viable functions to be better candidates than non-viable
4195 // functions.
4196 if (!Cand2.Viable)
4197 return Cand1.Viable;
4198 else if (!Cand1.Viable)
4199 return false;
4200
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004201 // C++ [over.match.best]p1:
4202 //
4203 // -- if F is a static member function, ICS1(F) is defined such
4204 // that ICS1(F) is neither better nor worse than ICS1(G) for
4205 // any function G, and, symmetrically, ICS1(G) is neither
4206 // better nor worse than ICS1(F).
4207 unsigned StartArg = 0;
4208 if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument)
4209 StartArg = 1;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004210
Douglas Gregord3cb3562009-07-07 23:38:56 +00004211 // C++ [over.match.best]p1:
Mike Stump11289f42009-09-09 15:08:12 +00004212 // A viable function F1 is defined to be a better function than another
4213 // viable function F2 if for all arguments i, ICSi(F1) is not a worse
Douglas Gregord3cb3562009-07-07 23:38:56 +00004214 // conversion sequence than ICSi(F2), and then...
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004215 unsigned NumArgs = Cand1.Conversions.size();
4216 assert(Cand2.Conversions.size() == NumArgs && "Overload candidate mismatch");
4217 bool HasBetterConversion = false;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004218 for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004219 switch (CompareImplicitConversionSequences(Cand1.Conversions[ArgIdx],
4220 Cand2.Conversions[ArgIdx])) {
4221 case ImplicitConversionSequence::Better:
4222 // Cand1 has a better conversion sequence.
4223 HasBetterConversion = true;
4224 break;
4225
4226 case ImplicitConversionSequence::Worse:
4227 // Cand1 can't be better than Cand2.
4228 return false;
4229
4230 case ImplicitConversionSequence::Indistinguishable:
4231 // Do nothing.
4232 break;
4233 }
4234 }
4235
Mike Stump11289f42009-09-09 15:08:12 +00004236 // -- for some argument j, ICSj(F1) is a better conversion sequence than
Douglas Gregord3cb3562009-07-07 23:38:56 +00004237 // ICSj(F2), or, if not that,
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004238 if (HasBetterConversion)
4239 return true;
4240
Mike Stump11289f42009-09-09 15:08:12 +00004241 // - F1 is a non-template function and F2 is a function template
Douglas Gregord3cb3562009-07-07 23:38:56 +00004242 // specialization, or, if not that,
4243 if (Cand1.Function && !Cand1.Function->getPrimaryTemplate() &&
4244 Cand2.Function && Cand2.Function->getPrimaryTemplate())
4245 return true;
Mike Stump11289f42009-09-09 15:08:12 +00004246
4247 // -- F1 and F2 are function template specializations, and the function
4248 // template for F1 is more specialized than the template for F2
4249 // according to the partial ordering rules described in 14.5.5.2, or,
Douglas Gregord3cb3562009-07-07 23:38:56 +00004250 // if not that,
Douglas Gregor55137cb2009-08-02 23:46:29 +00004251 if (Cand1.Function && Cand1.Function->getPrimaryTemplate() &&
4252 Cand2.Function && Cand2.Function->getPrimaryTemplate())
Douglas Gregor05155d82009-08-21 23:19:43 +00004253 if (FunctionTemplateDecl *BetterTemplate
4254 = getMoreSpecializedTemplate(Cand1.Function->getPrimaryTemplate(),
4255 Cand2.Function->getPrimaryTemplate(),
John McCallbc077cf2010-02-08 23:07:23 +00004256 Loc,
Douglas Gregor6010da02009-09-14 23:02:14 +00004257 isa<CXXConversionDecl>(Cand1.Function)? TPOC_Conversion
4258 : TPOC_Call))
Douglas Gregor05155d82009-08-21 23:19:43 +00004259 return BetterTemplate == Cand1.Function->getPrimaryTemplate();
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004260
Douglas Gregora1f013e2008-11-07 22:36:19 +00004261 // -- the context is an initialization by user-defined conversion
4262 // (see 8.5, 13.3.1.5) and the standard conversion sequence
4263 // from the return type of F1 to the destination type (i.e.,
4264 // the type of the entity being initialized) is a better
4265 // conversion sequence than the standard conversion sequence
4266 // from the return type of F2 to the destination type.
Mike Stump11289f42009-09-09 15:08:12 +00004267 if (Cand1.Function && Cand2.Function &&
4268 isa<CXXConversionDecl>(Cand1.Function) &&
Douglas Gregora1f013e2008-11-07 22:36:19 +00004269 isa<CXXConversionDecl>(Cand2.Function)) {
4270 switch (CompareStandardConversionSequences(Cand1.FinalConversion,
4271 Cand2.FinalConversion)) {
4272 case ImplicitConversionSequence::Better:
4273 // Cand1 has a better conversion sequence.
4274 return true;
4275
4276 case ImplicitConversionSequence::Worse:
4277 // Cand1 can't be better than Cand2.
4278 return false;
4279
4280 case ImplicitConversionSequence::Indistinguishable:
4281 // Do nothing
4282 break;
4283 }
4284 }
4285
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004286 return false;
4287}
4288
Mike Stump11289f42009-09-09 15:08:12 +00004289/// \brief Computes the best viable function (C++ 13.3.3)
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00004290/// within an overload candidate set.
4291///
4292/// \param CandidateSet the set of candidate functions.
4293///
4294/// \param Loc the location of the function name (or operator symbol) for
4295/// which overload resolution occurs.
4296///
Mike Stump11289f42009-09-09 15:08:12 +00004297/// \param Best f overload resolution was successful or found a deleted
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00004298/// function, Best points to the candidate function found.
4299///
4300/// \returns The result of overload resolution.
Douglas Gregor3e1e5272009-12-09 23:02:17 +00004301OverloadingResult Sema::BestViableFunction(OverloadCandidateSet& CandidateSet,
4302 SourceLocation Loc,
4303 OverloadCandidateSet::iterator& Best) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004304 // Find the best viable function.
4305 Best = CandidateSet.end();
4306 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4307 Cand != CandidateSet.end(); ++Cand) {
4308 if (Cand->Viable) {
John McCallbc077cf2010-02-08 23:07:23 +00004309 if (Best == CandidateSet.end() ||
4310 isBetterOverloadCandidate(*Cand, *Best, Loc))
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004311 Best = Cand;
4312 }
4313 }
4314
4315 // If we didn't find any viable functions, abort.
4316 if (Best == CandidateSet.end())
4317 return OR_No_Viable_Function;
4318
4319 // Make sure that this function is better than every other viable
4320 // function. If not, we have an ambiguity.
4321 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4322 Cand != CandidateSet.end(); ++Cand) {
Mike Stump11289f42009-09-09 15:08:12 +00004323 if (Cand->Viable &&
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004324 Cand != Best &&
John McCallbc077cf2010-02-08 23:07:23 +00004325 !isBetterOverloadCandidate(*Best, *Cand, Loc)) {
Douglas Gregorab7897a2008-11-19 22:57:39 +00004326 Best = CandidateSet.end();
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004327 return OR_Ambiguous;
Douglas Gregorab7897a2008-11-19 22:57:39 +00004328 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004329 }
Mike Stump11289f42009-09-09 15:08:12 +00004330
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004331 // Best is the best viable function.
Douglas Gregor171c45a2009-02-18 21:56:37 +00004332 if (Best->Function &&
Mike Stump11289f42009-09-09 15:08:12 +00004333 (Best->Function->isDeleted() ||
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00004334 Best->Function->getAttr<UnavailableAttr>()))
Douglas Gregor171c45a2009-02-18 21:56:37 +00004335 return OR_Deleted;
4336
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00004337 // C++ [basic.def.odr]p2:
4338 // An overloaded function is used if it is selected by overload resolution
Mike Stump11289f42009-09-09 15:08:12 +00004339 // when referred to from a potentially-evaluated expression. [Note: this
4340 // covers calls to named functions (5.2.2), operator overloading
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00004341 // (clause 13), user-defined conversions (12.3.2), allocation function for
4342 // placement new (5.3.4), as well as non-default initialization (8.5).
4343 if (Best->Function)
4344 MarkDeclarationReferenced(Loc, Best->Function);
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004345 return OR_Success;
4346}
4347
John McCall53262c92010-01-12 02:15:36 +00004348namespace {
4349
4350enum OverloadCandidateKind {
4351 oc_function,
4352 oc_method,
4353 oc_constructor,
John McCalle1ac8d12010-01-13 00:25:19 +00004354 oc_function_template,
4355 oc_method_template,
4356 oc_constructor_template,
John McCall53262c92010-01-12 02:15:36 +00004357 oc_implicit_default_constructor,
4358 oc_implicit_copy_constructor,
John McCalle1ac8d12010-01-13 00:25:19 +00004359 oc_implicit_copy_assignment
John McCall53262c92010-01-12 02:15:36 +00004360};
4361
John McCalle1ac8d12010-01-13 00:25:19 +00004362OverloadCandidateKind ClassifyOverloadCandidate(Sema &S,
4363 FunctionDecl *Fn,
4364 std::string &Description) {
4365 bool isTemplate = false;
4366
4367 if (FunctionTemplateDecl *FunTmpl = Fn->getPrimaryTemplate()) {
4368 isTemplate = true;
4369 Description = S.getTemplateArgumentBindingsText(
4370 FunTmpl->getTemplateParameters(), *Fn->getTemplateSpecializationArgs());
4371 }
John McCallfd0b2f82010-01-06 09:43:14 +00004372
4373 if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
John McCall53262c92010-01-12 02:15:36 +00004374 if (!Ctor->isImplicit())
John McCalle1ac8d12010-01-13 00:25:19 +00004375 return isTemplate ? oc_constructor_template : oc_constructor;
John McCallfd0b2f82010-01-06 09:43:14 +00004376
John McCall53262c92010-01-12 02:15:36 +00004377 return Ctor->isCopyConstructor() ? oc_implicit_copy_constructor
4378 : oc_implicit_default_constructor;
John McCallfd0b2f82010-01-06 09:43:14 +00004379 }
4380
4381 if (CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
4382 // This actually gets spelled 'candidate function' for now, but
4383 // it doesn't hurt to split it out.
John McCall53262c92010-01-12 02:15:36 +00004384 if (!Meth->isImplicit())
John McCalle1ac8d12010-01-13 00:25:19 +00004385 return isTemplate ? oc_method_template : oc_method;
John McCallfd0b2f82010-01-06 09:43:14 +00004386
4387 assert(Meth->isCopyAssignment()
4388 && "implicit method is not copy assignment operator?");
John McCall53262c92010-01-12 02:15:36 +00004389 return oc_implicit_copy_assignment;
4390 }
4391
John McCalle1ac8d12010-01-13 00:25:19 +00004392 return isTemplate ? oc_function_template : oc_function;
John McCall53262c92010-01-12 02:15:36 +00004393}
4394
4395} // end anonymous namespace
4396
4397// Notes the location of an overload candidate.
4398void Sema::NoteOverloadCandidate(FunctionDecl *Fn) {
John McCalle1ac8d12010-01-13 00:25:19 +00004399 std::string FnDesc;
4400 OverloadCandidateKind K = ClassifyOverloadCandidate(*this, Fn, FnDesc);
4401 Diag(Fn->getLocation(), diag::note_ovl_candidate)
4402 << (unsigned) K << FnDesc;
John McCallfd0b2f82010-01-06 09:43:14 +00004403}
4404
John McCall0d1da222010-01-12 00:44:57 +00004405/// Diagnoses an ambiguous conversion. The partial diagnostic is the
4406/// "lead" diagnostic; it will be given two arguments, the source and
4407/// target types of the conversion.
4408void Sema::DiagnoseAmbiguousConversion(const ImplicitConversionSequence &ICS,
4409 SourceLocation CaretLoc,
4410 const PartialDiagnostic &PDiag) {
4411 Diag(CaretLoc, PDiag)
4412 << ICS.Ambiguous.getFromType() << ICS.Ambiguous.getToType();
4413 for (AmbiguousConversionSequence::const_iterator
4414 I = ICS.Ambiguous.begin(), E = ICS.Ambiguous.end(); I != E; ++I) {
4415 NoteOverloadCandidate(*I);
4416 }
John McCall12f97bc2010-01-08 04:41:39 +00004417}
4418
John McCall0d1da222010-01-12 00:44:57 +00004419namespace {
4420
John McCall6a61b522010-01-13 09:16:55 +00004421void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I) {
4422 const ImplicitConversionSequence &Conv = Cand->Conversions[I];
4423 assert(Conv.isBad());
John McCalle1ac8d12010-01-13 00:25:19 +00004424 assert(Cand->Function && "for now, candidate must be a function");
4425 FunctionDecl *Fn = Cand->Function;
4426
4427 // There's a conversion slot for the object argument if this is a
4428 // non-constructor method. Note that 'I' corresponds the
4429 // conversion-slot index.
John McCall6a61b522010-01-13 09:16:55 +00004430 bool isObjectArgument = false;
John McCalle1ac8d12010-01-13 00:25:19 +00004431 if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) {
John McCall6a61b522010-01-13 09:16:55 +00004432 if (I == 0)
4433 isObjectArgument = true;
4434 else
4435 I--;
John McCalle1ac8d12010-01-13 00:25:19 +00004436 }
4437
John McCalle1ac8d12010-01-13 00:25:19 +00004438 std::string FnDesc;
4439 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, FnDesc);
4440
John McCall6a61b522010-01-13 09:16:55 +00004441 Expr *FromExpr = Conv.Bad.FromExpr;
4442 QualType FromTy = Conv.Bad.getFromType();
4443 QualType ToTy = Conv.Bad.getToType();
John McCalle1ac8d12010-01-13 00:25:19 +00004444
John McCallfb7ad0f2010-02-02 02:42:52 +00004445 if (FromTy == S.Context.OverloadTy) {
John McCall65eb8792010-02-25 01:37:24 +00004446 assert(FromExpr && "overload set argument came from implicit argument?");
John McCallfb7ad0f2010-02-02 02:42:52 +00004447 Expr *E = FromExpr->IgnoreParens();
4448 if (isa<UnaryOperator>(E))
4449 E = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
John McCall1acbbb52010-02-02 06:20:04 +00004450 DeclarationName Name = cast<OverloadExpr>(E)->getName();
John McCallfb7ad0f2010-02-02 02:42:52 +00004451
4452 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_overload)
4453 << (unsigned) FnKind << FnDesc
4454 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
4455 << ToTy << Name << I+1;
4456 return;
4457 }
4458
John McCall6d174642010-01-23 08:10:49 +00004459 // Do some hand-waving analysis to see if the non-viability is due
4460 // to a qualifier mismatch.
John McCall47000992010-01-14 03:28:57 +00004461 CanQualType CFromTy = S.Context.getCanonicalType(FromTy);
4462 CanQualType CToTy = S.Context.getCanonicalType(ToTy);
4463 if (CanQual<ReferenceType> RT = CToTy->getAs<ReferenceType>())
4464 CToTy = RT->getPointeeType();
4465 else {
4466 // TODO: detect and diagnose the full richness of const mismatches.
4467 if (CanQual<PointerType> FromPT = CFromTy->getAs<PointerType>())
4468 if (CanQual<PointerType> ToPT = CToTy->getAs<PointerType>())
4469 CFromTy = FromPT->getPointeeType(), CToTy = ToPT->getPointeeType();
4470 }
4471
4472 if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() &&
4473 !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {
4474 // It is dumb that we have to do this here.
4475 while (isa<ArrayType>(CFromTy))
4476 CFromTy = CFromTy->getAs<ArrayType>()->getElementType();
4477 while (isa<ArrayType>(CToTy))
4478 CToTy = CFromTy->getAs<ArrayType>()->getElementType();
4479
4480 Qualifiers FromQs = CFromTy.getQualifiers();
4481 Qualifiers ToQs = CToTy.getQualifiers();
4482
4483 if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) {
4484 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace)
4485 << (unsigned) FnKind << FnDesc
4486 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
4487 << FromTy
4488 << FromQs.getAddressSpace() << ToQs.getAddressSpace()
4489 << (unsigned) isObjectArgument << I+1;
4490 return;
4491 }
4492
4493 unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
4494 assert(CVR && "unexpected qualifiers mismatch");
4495
4496 if (isObjectArgument) {
4497 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr_this)
4498 << (unsigned) FnKind << FnDesc
4499 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
4500 << FromTy << (CVR - 1);
4501 } else {
4502 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr)
4503 << (unsigned) FnKind << FnDesc
4504 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
4505 << FromTy << (CVR - 1) << I+1;
4506 }
4507 return;
4508 }
4509
John McCall6d174642010-01-23 08:10:49 +00004510 // Diagnose references or pointers to incomplete types differently,
4511 // since it's far from impossible that the incompleteness triggered
4512 // the failure.
4513 QualType TempFromTy = FromTy.getNonReferenceType();
4514 if (const PointerType *PTy = TempFromTy->getAs<PointerType>())
4515 TempFromTy = PTy->getPointeeType();
4516 if (TempFromTy->isIncompleteType()) {
4517 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
4518 << (unsigned) FnKind << FnDesc
4519 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
4520 << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
4521 return;
4522 }
4523
John McCall47000992010-01-14 03:28:57 +00004524 // TODO: specialize more based on the kind of mismatch
John McCalle1ac8d12010-01-13 00:25:19 +00004525 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv)
4526 << (unsigned) FnKind << FnDesc
John McCall6a61b522010-01-13 09:16:55 +00004527 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
John McCalla1709fd2010-01-14 00:56:20 +00004528 << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
John McCall6a61b522010-01-13 09:16:55 +00004529}
4530
4531void DiagnoseArityMismatch(Sema &S, OverloadCandidate *Cand,
4532 unsigned NumFormalArgs) {
4533 // TODO: treat calls to a missing default constructor as a special case
4534
4535 FunctionDecl *Fn = Cand->Function;
4536 const FunctionProtoType *FnTy = Fn->getType()->getAs<FunctionProtoType>();
4537
4538 unsigned MinParams = Fn->getMinRequiredArguments();
4539
4540 // at least / at most / exactly
4541 unsigned mode, modeCount;
4542 if (NumFormalArgs < MinParams) {
4543 assert(Cand->FailureKind == ovl_fail_too_few_arguments);
4544 if (MinParams != FnTy->getNumArgs() || FnTy->isVariadic())
4545 mode = 0; // "at least"
4546 else
4547 mode = 2; // "exactly"
4548 modeCount = MinParams;
4549 } else {
4550 assert(Cand->FailureKind == ovl_fail_too_many_arguments);
4551 if (MinParams != FnTy->getNumArgs())
4552 mode = 1; // "at most"
4553 else
4554 mode = 2; // "exactly"
4555 modeCount = FnTy->getNumArgs();
4556 }
4557
4558 std::string Description;
4559 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, Description);
4560
4561 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity)
4562 << (unsigned) FnKind << Description << mode << modeCount << NumFormalArgs;
John McCalle1ac8d12010-01-13 00:25:19 +00004563}
4564
John McCall8b9ed552010-02-01 18:53:26 +00004565/// Diagnose a failed template-argument deduction.
4566void DiagnoseBadDeduction(Sema &S, OverloadCandidate *Cand,
4567 Expr **Args, unsigned NumArgs) {
4568 FunctionDecl *Fn = Cand->Function; // pattern
4569
4570 TemplateParameter Param = TemplateParameter::getFromOpaqueValue(
4571 Cand->DeductionFailure.TemplateParameter);
4572
4573 switch (Cand->DeductionFailure.Result) {
4574 case Sema::TDK_Success:
4575 llvm_unreachable("TDK_success while diagnosing bad deduction");
4576
4577 case Sema::TDK_Incomplete: {
4578 NamedDecl *ParamD;
4579 (ParamD = Param.dyn_cast<TemplateTypeParmDecl*>()) ||
4580 (ParamD = Param.dyn_cast<NonTypeTemplateParmDecl*>()) ||
4581 (ParamD = Param.dyn_cast<TemplateTemplateParmDecl*>());
4582 assert(ParamD && "no parameter found for incomplete deduction result");
4583 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_incomplete_deduction)
4584 << ParamD->getDeclName();
4585 return;
4586 }
4587
4588 // TODO: diagnose these individually, then kill off
4589 // note_ovl_candidate_bad_deduction, which is uselessly vague.
4590 case Sema::TDK_InstantiationDepth:
4591 case Sema::TDK_Inconsistent:
4592 case Sema::TDK_InconsistentQuals:
4593 case Sema::TDK_SubstitutionFailure:
4594 case Sema::TDK_NonDeducedMismatch:
4595 case Sema::TDK_TooManyArguments:
4596 case Sema::TDK_TooFewArguments:
4597 case Sema::TDK_InvalidExplicitArguments:
4598 case Sema::TDK_FailedOverloadResolution:
4599 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_deduction);
4600 return;
4601 }
4602}
4603
4604/// Generates a 'note' diagnostic for an overload candidate. We've
4605/// already generated a primary error at the call site.
4606///
4607/// It really does need to be a single diagnostic with its caret
4608/// pointed at the candidate declaration. Yes, this creates some
4609/// major challenges of technical writing. Yes, this makes pointing
4610/// out problems with specific arguments quite awkward. It's still
4611/// better than generating twenty screens of text for every failed
4612/// overload.
4613///
4614/// It would be great to be able to express per-candidate problems
4615/// more richly for those diagnostic clients that cared, but we'd
4616/// still have to be just as careful with the default diagnostics.
John McCalle1ac8d12010-01-13 00:25:19 +00004617void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand,
4618 Expr **Args, unsigned NumArgs) {
John McCall53262c92010-01-12 02:15:36 +00004619 FunctionDecl *Fn = Cand->Function;
4620
John McCall12f97bc2010-01-08 04:41:39 +00004621 // Note deleted candidates, but only if they're viable.
John McCall53262c92010-01-12 02:15:36 +00004622 if (Cand->Viable && (Fn->isDeleted() || Fn->hasAttr<UnavailableAttr>())) {
John McCalle1ac8d12010-01-13 00:25:19 +00004623 std::string FnDesc;
4624 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, FnDesc);
John McCall53262c92010-01-12 02:15:36 +00004625
4626 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted)
John McCalle1ac8d12010-01-13 00:25:19 +00004627 << FnKind << FnDesc << Fn->isDeleted();
John McCalld3224162010-01-08 00:58:21 +00004628 return;
John McCall12f97bc2010-01-08 04:41:39 +00004629 }
4630
John McCalle1ac8d12010-01-13 00:25:19 +00004631 // We don't really have anything else to say about viable candidates.
4632 if (Cand->Viable) {
4633 S.NoteOverloadCandidate(Fn);
4634 return;
4635 }
John McCall0d1da222010-01-12 00:44:57 +00004636
John McCall6a61b522010-01-13 09:16:55 +00004637 switch (Cand->FailureKind) {
4638 case ovl_fail_too_many_arguments:
4639 case ovl_fail_too_few_arguments:
4640 return DiagnoseArityMismatch(S, Cand, NumArgs);
John McCalle1ac8d12010-01-13 00:25:19 +00004641
John McCall6a61b522010-01-13 09:16:55 +00004642 case ovl_fail_bad_deduction:
John McCall8b9ed552010-02-01 18:53:26 +00004643 return DiagnoseBadDeduction(S, Cand, Args, NumArgs);
4644
John McCallfe796dd2010-01-23 05:17:32 +00004645 case ovl_fail_trivial_conversion:
4646 case ovl_fail_bad_final_conversion:
John McCall6a61b522010-01-13 09:16:55 +00004647 return S.NoteOverloadCandidate(Fn);
John McCalle1ac8d12010-01-13 00:25:19 +00004648
John McCall65eb8792010-02-25 01:37:24 +00004649 case ovl_fail_bad_conversion: {
4650 unsigned I = (Cand->IgnoreObjectArgument ? 1 : 0);
4651 for (unsigned N = Cand->Conversions.size(); I != N; ++I)
John McCall6a61b522010-01-13 09:16:55 +00004652 if (Cand->Conversions[I].isBad())
4653 return DiagnoseBadConversion(S, Cand, I);
4654
4655 // FIXME: this currently happens when we're called from SemaInit
4656 // when user-conversion overload fails. Figure out how to handle
4657 // those conditions and diagnose them well.
4658 return S.NoteOverloadCandidate(Fn);
John McCalle1ac8d12010-01-13 00:25:19 +00004659 }
John McCall65eb8792010-02-25 01:37:24 +00004660 }
John McCalld3224162010-01-08 00:58:21 +00004661}
4662
4663void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand) {
4664 // Desugar the type of the surrogate down to a function type,
4665 // retaining as many typedefs as possible while still showing
4666 // the function type (and, therefore, its parameter types).
4667 QualType FnType = Cand->Surrogate->getConversionType();
4668 bool isLValueReference = false;
4669 bool isRValueReference = false;
4670 bool isPointer = false;
4671 if (const LValueReferenceType *FnTypeRef =
4672 FnType->getAs<LValueReferenceType>()) {
4673 FnType = FnTypeRef->getPointeeType();
4674 isLValueReference = true;
4675 } else if (const RValueReferenceType *FnTypeRef =
4676 FnType->getAs<RValueReferenceType>()) {
4677 FnType = FnTypeRef->getPointeeType();
4678 isRValueReference = true;
4679 }
4680 if (const PointerType *FnTypePtr = FnType->getAs<PointerType>()) {
4681 FnType = FnTypePtr->getPointeeType();
4682 isPointer = true;
4683 }
4684 // Desugar down to a function type.
4685 FnType = QualType(FnType->getAs<FunctionType>(), 0);
4686 // Reconstruct the pointer/reference as appropriate.
4687 if (isPointer) FnType = S.Context.getPointerType(FnType);
4688 if (isRValueReference) FnType = S.Context.getRValueReferenceType(FnType);
4689 if (isLValueReference) FnType = S.Context.getLValueReferenceType(FnType);
4690
4691 S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand)
4692 << FnType;
4693}
4694
4695void NoteBuiltinOperatorCandidate(Sema &S,
4696 const char *Opc,
4697 SourceLocation OpLoc,
4698 OverloadCandidate *Cand) {
4699 assert(Cand->Conversions.size() <= 2 && "builtin operator is not binary");
4700 std::string TypeStr("operator");
4701 TypeStr += Opc;
4702 TypeStr += "(";
4703 TypeStr += Cand->BuiltinTypes.ParamTypes[0].getAsString();
4704 if (Cand->Conversions.size() == 1) {
4705 TypeStr += ")";
4706 S.Diag(OpLoc, diag::note_ovl_builtin_unary_candidate) << TypeStr;
4707 } else {
4708 TypeStr += ", ";
4709 TypeStr += Cand->BuiltinTypes.ParamTypes[1].getAsString();
4710 TypeStr += ")";
4711 S.Diag(OpLoc, diag::note_ovl_builtin_binary_candidate) << TypeStr;
4712 }
4713}
4714
4715void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc,
4716 OverloadCandidate *Cand) {
4717 unsigned NoOperands = Cand->Conversions.size();
4718 for (unsigned ArgIdx = 0; ArgIdx < NoOperands; ++ArgIdx) {
4719 const ImplicitConversionSequence &ICS = Cand->Conversions[ArgIdx];
John McCall0d1da222010-01-12 00:44:57 +00004720 if (ICS.isBad()) break; // all meaningless after first invalid
4721 if (!ICS.isAmbiguous()) continue;
4722
4723 S.DiagnoseAmbiguousConversion(ICS, OpLoc,
4724 PDiag(diag::note_ambiguous_type_conversion));
John McCalld3224162010-01-08 00:58:21 +00004725 }
4726}
4727
John McCall3712d9e2010-01-15 23:32:50 +00004728SourceLocation GetLocationForCandidate(const OverloadCandidate *Cand) {
4729 if (Cand->Function)
4730 return Cand->Function->getLocation();
John McCall982adb52010-01-16 03:50:16 +00004731 if (Cand->IsSurrogate)
John McCall3712d9e2010-01-15 23:32:50 +00004732 return Cand->Surrogate->getLocation();
4733 return SourceLocation();
4734}
4735
John McCallad2587a2010-01-12 00:48:53 +00004736struct CompareOverloadCandidatesForDisplay {
4737 Sema &S;
4738 CompareOverloadCandidatesForDisplay(Sema &S) : S(S) {}
John McCall12f97bc2010-01-08 04:41:39 +00004739
4740 bool operator()(const OverloadCandidate *L,
4741 const OverloadCandidate *R) {
John McCall982adb52010-01-16 03:50:16 +00004742 // Fast-path this check.
4743 if (L == R) return false;
4744
John McCall12f97bc2010-01-08 04:41:39 +00004745 // Order first by viability.
John McCallad2587a2010-01-12 00:48:53 +00004746 if (L->Viable) {
4747 if (!R->Viable) return true;
4748
4749 // TODO: introduce a tri-valued comparison for overload
4750 // candidates. Would be more worthwhile if we had a sort
4751 // that could exploit it.
John McCallbc077cf2010-02-08 23:07:23 +00004752 if (S.isBetterOverloadCandidate(*L, *R, SourceLocation())) return true;
4753 if (S.isBetterOverloadCandidate(*R, *L, SourceLocation())) return false;
John McCallad2587a2010-01-12 00:48:53 +00004754 } else if (R->Viable)
4755 return false;
John McCall12f97bc2010-01-08 04:41:39 +00004756
John McCall3712d9e2010-01-15 23:32:50 +00004757 assert(L->Viable == R->Viable);
John McCall12f97bc2010-01-08 04:41:39 +00004758
John McCall3712d9e2010-01-15 23:32:50 +00004759 // Criteria by which we can sort non-viable candidates:
4760 if (!L->Viable) {
4761 // 1. Arity mismatches come after other candidates.
4762 if (L->FailureKind == ovl_fail_too_many_arguments ||
4763 L->FailureKind == ovl_fail_too_few_arguments)
4764 return false;
4765 if (R->FailureKind == ovl_fail_too_many_arguments ||
4766 R->FailureKind == ovl_fail_too_few_arguments)
4767 return true;
John McCall12f97bc2010-01-08 04:41:39 +00004768
John McCallfe796dd2010-01-23 05:17:32 +00004769 // 2. Bad conversions come first and are ordered by the number
4770 // of bad conversions and quality of good conversions.
4771 if (L->FailureKind == ovl_fail_bad_conversion) {
4772 if (R->FailureKind != ovl_fail_bad_conversion)
4773 return true;
4774
4775 // If there's any ordering between the defined conversions...
4776 // FIXME: this might not be transitive.
4777 assert(L->Conversions.size() == R->Conversions.size());
4778
4779 int leftBetter = 0;
John McCall21b57fa2010-02-25 10:46:05 +00004780 unsigned I = (L->IgnoreObjectArgument || R->IgnoreObjectArgument);
4781 for (unsigned E = L->Conversions.size(); I != E; ++I) {
John McCallfe796dd2010-01-23 05:17:32 +00004782 switch (S.CompareImplicitConversionSequences(L->Conversions[I],
4783 R->Conversions[I])) {
4784 case ImplicitConversionSequence::Better:
4785 leftBetter++;
4786 break;
4787
4788 case ImplicitConversionSequence::Worse:
4789 leftBetter--;
4790 break;
4791
4792 case ImplicitConversionSequence::Indistinguishable:
4793 break;
4794 }
4795 }
4796 if (leftBetter > 0) return true;
4797 if (leftBetter < 0) return false;
4798
4799 } else if (R->FailureKind == ovl_fail_bad_conversion)
4800 return false;
4801
John McCall3712d9e2010-01-15 23:32:50 +00004802 // TODO: others?
4803 }
4804
4805 // Sort everything else by location.
4806 SourceLocation LLoc = GetLocationForCandidate(L);
4807 SourceLocation RLoc = GetLocationForCandidate(R);
4808
4809 // Put candidates without locations (e.g. builtins) at the end.
4810 if (LLoc.isInvalid()) return false;
4811 if (RLoc.isInvalid()) return true;
4812
4813 return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
John McCall12f97bc2010-01-08 04:41:39 +00004814 }
4815};
4816
John McCallfe796dd2010-01-23 05:17:32 +00004817/// CompleteNonViableCandidate - Normally, overload resolution only
4818/// computes up to the first
4819void CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand,
4820 Expr **Args, unsigned NumArgs) {
4821 assert(!Cand->Viable);
4822
4823 // Don't do anything on failures other than bad conversion.
4824 if (Cand->FailureKind != ovl_fail_bad_conversion) return;
4825
4826 // Skip forward to the first bad conversion.
John McCall65eb8792010-02-25 01:37:24 +00004827 unsigned ConvIdx = (Cand->IgnoreObjectArgument ? 1 : 0);
John McCallfe796dd2010-01-23 05:17:32 +00004828 unsigned ConvCount = Cand->Conversions.size();
4829 while (true) {
4830 assert(ConvIdx != ConvCount && "no bad conversion in candidate");
4831 ConvIdx++;
4832 if (Cand->Conversions[ConvIdx - 1].isBad())
4833 break;
4834 }
4835
4836 if (ConvIdx == ConvCount)
4837 return;
4838
John McCall65eb8792010-02-25 01:37:24 +00004839 assert(!Cand->Conversions[ConvIdx].isInitialized() &&
4840 "remaining conversion is initialized?");
4841
John McCallfe796dd2010-01-23 05:17:32 +00004842 // FIXME: these should probably be preserved from the overload
4843 // operation somehow.
4844 bool SuppressUserConversions = false;
4845 bool ForceRValue = false;
4846
4847 const FunctionProtoType* Proto;
4848 unsigned ArgIdx = ConvIdx;
4849
4850 if (Cand->IsSurrogate) {
4851 QualType ConvType
4852 = Cand->Surrogate->getConversionType().getNonReferenceType();
4853 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
4854 ConvType = ConvPtrType->getPointeeType();
4855 Proto = ConvType->getAs<FunctionProtoType>();
4856 ArgIdx--;
4857 } else if (Cand->Function) {
4858 Proto = Cand->Function->getType()->getAs<FunctionProtoType>();
4859 if (isa<CXXMethodDecl>(Cand->Function) &&
4860 !isa<CXXConstructorDecl>(Cand->Function))
4861 ArgIdx--;
4862 } else {
4863 // Builtin binary operator with a bad first conversion.
4864 assert(ConvCount <= 3);
4865 for (; ConvIdx != ConvCount; ++ConvIdx)
4866 Cand->Conversions[ConvIdx]
4867 = S.TryCopyInitialization(Args[ConvIdx],
4868 Cand->BuiltinTypes.ParamTypes[ConvIdx],
4869 SuppressUserConversions, ForceRValue,
4870 /*InOverloadResolution*/ true);
4871 return;
4872 }
4873
4874 // Fill in the rest of the conversions.
4875 unsigned NumArgsInProto = Proto->getNumArgs();
4876 for (; ConvIdx != ConvCount; ++ConvIdx, ++ArgIdx) {
4877 if (ArgIdx < NumArgsInProto)
4878 Cand->Conversions[ConvIdx]
4879 = S.TryCopyInitialization(Args[ArgIdx], Proto->getArgType(ArgIdx),
4880 SuppressUserConversions, ForceRValue,
4881 /*InOverloadResolution=*/true);
4882 else
4883 Cand->Conversions[ConvIdx].setEllipsis();
4884 }
4885}
4886
John McCalld3224162010-01-08 00:58:21 +00004887} // end anonymous namespace
4888
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004889/// PrintOverloadCandidates - When overload resolution fails, prints
4890/// diagnostic messages containing the candidates in the candidate
John McCall12f97bc2010-01-08 04:41:39 +00004891/// set.
Mike Stump11289f42009-09-09 15:08:12 +00004892void
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004893Sema::PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
John McCall12f97bc2010-01-08 04:41:39 +00004894 OverloadCandidateDisplayKind OCD,
John McCallad907772010-01-12 07:18:19 +00004895 Expr **Args, unsigned NumArgs,
Fariborz Jahaniane7196432009-10-12 20:11:40 +00004896 const char *Opc,
Fariborz Jahanian29f9d392009-10-09 00:13:15 +00004897 SourceLocation OpLoc) {
John McCall12f97bc2010-01-08 04:41:39 +00004898 // Sort the candidates by viability and position. Sorting directly would
4899 // be prohibitive, so we make a set of pointers and sort those.
4900 llvm::SmallVector<OverloadCandidate*, 32> Cands;
4901 if (OCD == OCD_AllCandidates) Cands.reserve(CandidateSet.size());
4902 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
4903 LastCand = CandidateSet.end();
John McCallfe796dd2010-01-23 05:17:32 +00004904 Cand != LastCand; ++Cand) {
4905 if (Cand->Viable)
John McCall12f97bc2010-01-08 04:41:39 +00004906 Cands.push_back(Cand);
John McCallfe796dd2010-01-23 05:17:32 +00004907 else if (OCD == OCD_AllCandidates) {
4908 CompleteNonViableCandidate(*this, Cand, Args, NumArgs);
4909 Cands.push_back(Cand);
4910 }
4911 }
4912
John McCallad2587a2010-01-12 00:48:53 +00004913 std::sort(Cands.begin(), Cands.end(),
4914 CompareOverloadCandidatesForDisplay(*this));
John McCall12f97bc2010-01-08 04:41:39 +00004915
John McCall0d1da222010-01-12 00:44:57 +00004916 bool ReportedAmbiguousConversions = false;
John McCalld3224162010-01-08 00:58:21 +00004917
John McCall12f97bc2010-01-08 04:41:39 +00004918 llvm::SmallVectorImpl<OverloadCandidate*>::iterator I, E;
4919 for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
4920 OverloadCandidate *Cand = *I;
Douglas Gregor4fc308b2008-11-21 02:54:28 +00004921
John McCalld3224162010-01-08 00:58:21 +00004922 if (Cand->Function)
John McCalle1ac8d12010-01-13 00:25:19 +00004923 NoteFunctionCandidate(*this, Cand, Args, NumArgs);
John McCalld3224162010-01-08 00:58:21 +00004924 else if (Cand->IsSurrogate)
4925 NoteSurrogateCandidate(*this, Cand);
4926
4927 // This a builtin candidate. We do not, in general, want to list
4928 // every possible builtin candidate.
John McCall0d1da222010-01-12 00:44:57 +00004929 else if (Cand->Viable) {
4930 // Generally we only see ambiguities including viable builtin
4931 // operators if overload resolution got screwed up by an
4932 // ambiguous user-defined conversion.
4933 //
4934 // FIXME: It's quite possible for different conversions to see
4935 // different ambiguities, though.
4936 if (!ReportedAmbiguousConversions) {
4937 NoteAmbiguousUserConversions(*this, OpLoc, Cand);
4938 ReportedAmbiguousConversions = true;
4939 }
John McCalld3224162010-01-08 00:58:21 +00004940
John McCall0d1da222010-01-12 00:44:57 +00004941 // If this is a viable builtin, print it.
John McCalld3224162010-01-08 00:58:21 +00004942 NoteBuiltinOperatorCandidate(*this, Opc, OpLoc, Cand);
Douglas Gregora11693b2008-11-12 17:17:38 +00004943 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +00004944 }
4945}
4946
John McCall1acbbb52010-02-02 06:20:04 +00004947static bool CheckUnresolvedAccess(Sema &S, OverloadExpr *E, NamedDecl *D,
John McCall58cc69d2010-01-27 01:50:18 +00004948 AccessSpecifier AS) {
4949 if (isa<UnresolvedLookupExpr>(E))
4950 return S.CheckUnresolvedLookupAccess(cast<UnresolvedLookupExpr>(E), D, AS);
4951
4952 return S.CheckUnresolvedMemberAccess(cast<UnresolvedMemberExpr>(E), D, AS);
4953}
4954
Douglas Gregorcd695e52008-11-10 20:40:00 +00004955/// ResolveAddressOfOverloadedFunction - Try to resolve the address of
4956/// an overloaded function (C++ [over.over]), where @p From is an
4957/// expression with overloaded function type and @p ToType is the type
4958/// we're trying to resolve to. For example:
4959///
4960/// @code
4961/// int f(double);
4962/// int f(int);
Mike Stump11289f42009-09-09 15:08:12 +00004963///
Douglas Gregorcd695e52008-11-10 20:40:00 +00004964/// int (*pfd)(double) = f; // selects f(double)
4965/// @endcode
4966///
4967/// This routine returns the resulting FunctionDecl if it could be
4968/// resolved, and NULL otherwise. When @p Complain is true, this
4969/// routine will emit diagnostics if there is an error.
4970FunctionDecl *
Sebastian Redl18f8ff62009-02-04 21:23:32 +00004971Sema::ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
Douglas Gregorcd695e52008-11-10 20:40:00 +00004972 bool Complain) {
4973 QualType FunctionType = ToType;
Sebastian Redl18f8ff62009-02-04 21:23:32 +00004974 bool IsMember = false;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004975 if (const PointerType *ToTypePtr = ToType->getAs<PointerType>())
Douglas Gregorcd695e52008-11-10 20:40:00 +00004976 FunctionType = ToTypePtr->getPointeeType();
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004977 else if (const ReferenceType *ToTypeRef = ToType->getAs<ReferenceType>())
Daniel Dunbarb566c6c2009-02-26 19:13:44 +00004978 FunctionType = ToTypeRef->getPointeeType();
Sebastian Redl18f8ff62009-02-04 21:23:32 +00004979 else if (const MemberPointerType *MemTypePtr =
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004980 ToType->getAs<MemberPointerType>()) {
Sebastian Redl18f8ff62009-02-04 21:23:32 +00004981 FunctionType = MemTypePtr->getPointeeType();
4982 IsMember = true;
4983 }
Douglas Gregorcd695e52008-11-10 20:40:00 +00004984
4985 // We only look at pointers or references to functions.
Douglas Gregor6b6ba8b2009-07-09 17:16:51 +00004986 FunctionType = Context.getCanonicalType(FunctionType).getUnqualifiedType();
Douglas Gregor9b146582009-07-08 20:55:45 +00004987 if (!FunctionType->isFunctionType())
Douglas Gregorcd695e52008-11-10 20:40:00 +00004988 return 0;
4989
4990 // Find the actual overloaded function declaration.
John McCall1acbbb52010-02-02 06:20:04 +00004991 if (From->getType() != Context.OverloadTy)
4992 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00004993
Douglas Gregorcd695e52008-11-10 20:40:00 +00004994 // C++ [over.over]p1:
4995 // [...] [Note: any redundant set of parentheses surrounding the
4996 // overloaded function name is ignored (5.1). ]
Douglas Gregorcd695e52008-11-10 20:40:00 +00004997 // C++ [over.over]p1:
4998 // [...] The overloaded function name can be preceded by the &
4999 // operator.
John McCall1acbbb52010-02-02 06:20:04 +00005000 OverloadExpr *OvlExpr = OverloadExpr::find(From).getPointer();
5001 TemplateArgumentListInfo ETABuffer, *ExplicitTemplateArgs = 0;
5002 if (OvlExpr->hasExplicitTemplateArgs()) {
5003 OvlExpr->getExplicitTemplateArgs().copyInto(ETABuffer);
5004 ExplicitTemplateArgs = &ETABuffer;
Douglas Gregorcd695e52008-11-10 20:40:00 +00005005 }
5006
Douglas Gregorcd695e52008-11-10 20:40:00 +00005007 // Look through all of the overloaded functions, searching for one
5008 // whose type matches exactly.
John McCall58cc69d2010-01-27 01:50:18 +00005009 UnresolvedSet<4> Matches; // contains only FunctionDecls
Douglas Gregorb257e4f2009-07-08 23:33:52 +00005010 bool FoundNonTemplateFunction = false;
John McCall1acbbb52010-02-02 06:20:04 +00005011 for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
5012 E = OvlExpr->decls_end(); I != E; ++I) {
Chandler Carruthc25c6ee2009-12-29 06:17:27 +00005013 // Look through any using declarations to find the underlying function.
5014 NamedDecl *Fn = (*I)->getUnderlyingDecl();
5015
Douglas Gregorcd695e52008-11-10 20:40:00 +00005016 // C++ [over.over]p3:
5017 // Non-member functions and static member functions match
Sebastian Redl16d307d2009-02-05 12:33:33 +00005018 // targets of type "pointer-to-function" or "reference-to-function."
5019 // Nonstatic member functions match targets of
Sebastian Redl18f8ff62009-02-04 21:23:32 +00005020 // type "pointer-to-member-function."
5021 // Note that according to DR 247, the containing class does not matter.
Douglas Gregor9b146582009-07-08 20:55:45 +00005022
Mike Stump11289f42009-09-09 15:08:12 +00005023 if (FunctionTemplateDecl *FunctionTemplate
Chandler Carruthc25c6ee2009-12-29 06:17:27 +00005024 = dyn_cast<FunctionTemplateDecl>(Fn)) {
Mike Stump11289f42009-09-09 15:08:12 +00005025 if (CXXMethodDecl *Method
Douglas Gregorb257e4f2009-07-08 23:33:52 +00005026 = dyn_cast<CXXMethodDecl>(FunctionTemplate->getTemplatedDecl())) {
Mike Stump11289f42009-09-09 15:08:12 +00005027 // Skip non-static function templates when converting to pointer, and
Douglas Gregorb257e4f2009-07-08 23:33:52 +00005028 // static when converting to member pointer.
5029 if (Method->isStatic() == IsMember)
5030 continue;
5031 } else if (IsMember)
5032 continue;
Mike Stump11289f42009-09-09 15:08:12 +00005033
Douglas Gregorb257e4f2009-07-08 23:33:52 +00005034 // C++ [over.over]p2:
Mike Stump11289f42009-09-09 15:08:12 +00005035 // If the name is a function template, template argument deduction is
5036 // done (14.8.2.2), and if the argument deduction succeeds, the
5037 // resulting template argument list is used to generate a single
5038 // function template specialization, which is added to the set of
Douglas Gregorb257e4f2009-07-08 23:33:52 +00005039 // overloaded functions considered.
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00005040 // FIXME: We don't really want to build the specialization here, do we?
Douglas Gregor9b146582009-07-08 20:55:45 +00005041 FunctionDecl *Specialization = 0;
John McCallbc077cf2010-02-08 23:07:23 +00005042 TemplateDeductionInfo Info(Context, OvlExpr->getNameLoc());
Douglas Gregor9b146582009-07-08 20:55:45 +00005043 if (TemplateDeductionResult Result
John McCall1acbbb52010-02-02 06:20:04 +00005044 = DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs,
Douglas Gregor9b146582009-07-08 20:55:45 +00005045 FunctionType, Specialization, Info)) {
5046 // FIXME: make a note of the failed deduction for diagnostics.
5047 (void)Result;
5048 } else {
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00005049 // FIXME: If the match isn't exact, shouldn't we just drop this as
5050 // a candidate? Find a testcase before changing the code.
Mike Stump11289f42009-09-09 15:08:12 +00005051 assert(FunctionType
Douglas Gregor9b146582009-07-08 20:55:45 +00005052 == Context.getCanonicalType(Specialization->getType()));
John McCall58cc69d2010-01-27 01:50:18 +00005053 Matches.addDecl(cast<FunctionDecl>(Specialization->getCanonicalDecl()),
5054 I.getAccess());
Douglas Gregor9b146582009-07-08 20:55:45 +00005055 }
John McCalld14a8642009-11-21 08:51:07 +00005056
5057 continue;
Douglas Gregor9b146582009-07-08 20:55:45 +00005058 }
Mike Stump11289f42009-09-09 15:08:12 +00005059
Chandler Carruthc25c6ee2009-12-29 06:17:27 +00005060 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
Sebastian Redl18f8ff62009-02-04 21:23:32 +00005061 // Skip non-static functions when converting to pointer, and static
5062 // when converting to member pointer.
5063 if (Method->isStatic() == IsMember)
Douglas Gregorcd695e52008-11-10 20:40:00 +00005064 continue;
Douglas Gregord3319842009-10-24 04:59:53 +00005065
5066 // If we have explicit template arguments, skip non-templates.
John McCall1acbbb52010-02-02 06:20:04 +00005067 if (OvlExpr->hasExplicitTemplateArgs())
Douglas Gregord3319842009-10-24 04:59:53 +00005068 continue;
Douglas Gregorb257e4f2009-07-08 23:33:52 +00005069 } else if (IsMember)
Sebastian Redl18f8ff62009-02-04 21:23:32 +00005070 continue;
Douglas Gregorcd695e52008-11-10 20:40:00 +00005071
Chandler Carruthc25c6ee2009-12-29 06:17:27 +00005072 if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
Douglas Gregor40cb9ad2009-12-09 00:47:37 +00005073 QualType ResultTy;
5074 if (Context.hasSameUnqualifiedType(FunctionType, FunDecl->getType()) ||
5075 IsNoReturnConversion(Context, FunDecl->getType(), FunctionType,
5076 ResultTy)) {
John McCall58cc69d2010-01-27 01:50:18 +00005077 Matches.addDecl(cast<FunctionDecl>(FunDecl->getCanonicalDecl()),
5078 I.getAccess());
Douglas Gregorb257e4f2009-07-08 23:33:52 +00005079 FoundNonTemplateFunction = true;
5080 }
Mike Stump11289f42009-09-09 15:08:12 +00005081 }
Douglas Gregorcd695e52008-11-10 20:40:00 +00005082 }
5083
Douglas Gregorb257e4f2009-07-08 23:33:52 +00005084 // If there were 0 or 1 matches, we're done.
5085 if (Matches.empty())
5086 return 0;
Sebastian Redldf4b80e2009-10-17 21:12:09 +00005087 else if (Matches.size() == 1) {
John McCall58cc69d2010-01-27 01:50:18 +00005088 FunctionDecl *Result = cast<FunctionDecl>(*Matches.begin());
Sebastian Redldf4b80e2009-10-17 21:12:09 +00005089 MarkDeclarationReferenced(From->getLocStart(), Result);
John McCall58cc69d2010-01-27 01:50:18 +00005090 if (Complain)
5091 CheckUnresolvedAccess(*this, OvlExpr, Result, Matches.begin().getAccess());
Sebastian Redldf4b80e2009-10-17 21:12:09 +00005092 return Result;
5093 }
Douglas Gregorb257e4f2009-07-08 23:33:52 +00005094
5095 // C++ [over.over]p4:
5096 // If more than one function is selected, [...]
Douglas Gregorfae1d712009-09-26 03:56:17 +00005097 if (!FoundNonTemplateFunction) {
Douglas Gregor05155d82009-08-21 23:19:43 +00005098 // [...] and any given function template specialization F1 is
5099 // eliminated if the set contains a second function template
5100 // specialization whose function template is more specialized
5101 // than the function template of F1 according to the partial
5102 // ordering rules of 14.5.5.2.
5103
5104 // The algorithm specified above is quadratic. We instead use a
5105 // two-pass algorithm (similar to the one used to identify the
5106 // best viable function in an overload set) that identifies the
5107 // best function template (if it exists).
John McCall58cc69d2010-01-27 01:50:18 +00005108
5109 UnresolvedSetIterator Result =
5110 getMostSpecialized(Matches.begin(), Matches.end(),
Sebastian Redldf4b80e2009-10-17 21:12:09 +00005111 TPOC_Other, From->getLocStart(),
5112 PDiag(),
5113 PDiag(diag::err_addr_ovl_ambiguous)
John McCall58cc69d2010-01-27 01:50:18 +00005114 << Matches[0]->getDeclName(),
John McCalle1ac8d12010-01-13 00:25:19 +00005115 PDiag(diag::note_ovl_candidate)
5116 << (unsigned) oc_function_template);
John McCall58cc69d2010-01-27 01:50:18 +00005117 assert(Result != Matches.end() && "no most-specialized template");
5118 MarkDeclarationReferenced(From->getLocStart(), *Result);
5119 if (Complain)
5120 CheckUnresolvedAccess(*this, OvlExpr, *Result, Result.getAccess());
5121 return cast<FunctionDecl>(*Result);
Douglas Gregorb257e4f2009-07-08 23:33:52 +00005122 }
Mike Stump11289f42009-09-09 15:08:12 +00005123
Douglas Gregorfae1d712009-09-26 03:56:17 +00005124 // [...] any function template specializations in the set are
5125 // eliminated if the set also contains a non-template function, [...]
John McCall58cc69d2010-01-27 01:50:18 +00005126 for (unsigned I = 0, N = Matches.size(); I != N; ) {
5127 if (cast<FunctionDecl>(Matches[I].getDecl())->getPrimaryTemplate() == 0)
5128 ++I;
5129 else {
5130 Matches.erase(I);
5131 --N;
5132 }
5133 }
Douglas Gregorfae1d712009-09-26 03:56:17 +00005134
Mike Stump11289f42009-09-09 15:08:12 +00005135 // [...] After such eliminations, if any, there shall remain exactly one
Douglas Gregorb257e4f2009-07-08 23:33:52 +00005136 // selected function.
John McCall58cc69d2010-01-27 01:50:18 +00005137 if (Matches.size() == 1) {
5138 UnresolvedSetIterator Match = Matches.begin();
5139 MarkDeclarationReferenced(From->getLocStart(), *Match);
5140 if (Complain)
5141 CheckUnresolvedAccess(*this, OvlExpr, *Match, Match.getAccess());
5142 return cast<FunctionDecl>(*Match);
Sebastian Redldf4b80e2009-10-17 21:12:09 +00005143 }
Mike Stump11289f42009-09-09 15:08:12 +00005144
Douglas Gregorb257e4f2009-07-08 23:33:52 +00005145 // FIXME: We should probably return the same thing that BestViableFunction
5146 // returns (even if we issue the diagnostics here).
5147 Diag(From->getLocStart(), diag::err_addr_ovl_ambiguous)
John McCall58cc69d2010-01-27 01:50:18 +00005148 << Matches[0]->getDeclName();
5149 for (UnresolvedSetIterator I = Matches.begin(),
5150 E = Matches.end(); I != E; ++I)
5151 NoteOverloadCandidate(cast<FunctionDecl>(*I));
Douglas Gregorcd695e52008-11-10 20:40:00 +00005152 return 0;
5153}
5154
Douglas Gregor8364e6b2009-12-21 23:17:24 +00005155/// \brief Given an expression that refers to an overloaded function, try to
5156/// resolve that overloaded function expression down to a single function.
5157///
5158/// This routine can only resolve template-ids that refer to a single function
5159/// template, where that template-id refers to a single template whose template
5160/// arguments are either provided by the template-id or have defaults,
5161/// as described in C++0x [temp.arg.explicit]p3.
5162FunctionDecl *Sema::ResolveSingleFunctionTemplateSpecialization(Expr *From) {
5163 // C++ [over.over]p1:
5164 // [...] [Note: any redundant set of parentheses surrounding the
5165 // overloaded function name is ignored (5.1). ]
Douglas Gregor8364e6b2009-12-21 23:17:24 +00005166 // C++ [over.over]p1:
5167 // [...] The overloaded function name can be preceded by the &
5168 // operator.
John McCall1acbbb52010-02-02 06:20:04 +00005169
5170 if (From->getType() != Context.OverloadTy)
5171 return 0;
5172
5173 OverloadExpr *OvlExpr = OverloadExpr::find(From).getPointer();
Douglas Gregor8364e6b2009-12-21 23:17:24 +00005174
5175 // If we didn't actually find any template-ids, we're done.
John McCall1acbbb52010-02-02 06:20:04 +00005176 if (!OvlExpr->hasExplicitTemplateArgs())
Douglas Gregor8364e6b2009-12-21 23:17:24 +00005177 return 0;
John McCall1acbbb52010-02-02 06:20:04 +00005178
5179 TemplateArgumentListInfo ExplicitTemplateArgs;
5180 OvlExpr->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs);
Douglas Gregor8364e6b2009-12-21 23:17:24 +00005181
5182 // Look through all of the overloaded functions, searching for one
5183 // whose type matches exactly.
5184 FunctionDecl *Matched = 0;
John McCall1acbbb52010-02-02 06:20:04 +00005185 for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
5186 E = OvlExpr->decls_end(); I != E; ++I) {
Douglas Gregor8364e6b2009-12-21 23:17:24 +00005187 // C++0x [temp.arg.explicit]p3:
5188 // [...] In contexts where deduction is done and fails, or in contexts
5189 // where deduction is not done, if a template argument list is
5190 // specified and it, along with any default template arguments,
5191 // identifies a single function template specialization, then the
5192 // template-id is an lvalue for the function template specialization.
5193 FunctionTemplateDecl *FunctionTemplate = cast<FunctionTemplateDecl>(*I);
5194
5195 // C++ [over.over]p2:
5196 // If the name is a function template, template argument deduction is
5197 // done (14.8.2.2), and if the argument deduction succeeds, the
5198 // resulting template argument list is used to generate a single
5199 // function template specialization, which is added to the set of
5200 // overloaded functions considered.
Douglas Gregor8364e6b2009-12-21 23:17:24 +00005201 FunctionDecl *Specialization = 0;
John McCallbc077cf2010-02-08 23:07:23 +00005202 TemplateDeductionInfo Info(Context, OvlExpr->getNameLoc());
Douglas Gregor8364e6b2009-12-21 23:17:24 +00005203 if (TemplateDeductionResult Result
5204 = DeduceTemplateArguments(FunctionTemplate, &ExplicitTemplateArgs,
5205 Specialization, Info)) {
5206 // FIXME: make a note of the failed deduction for diagnostics.
5207 (void)Result;
5208 continue;
5209 }
5210
5211 // Multiple matches; we can't resolve to a single declaration.
5212 if (Matched)
5213 return 0;
5214
5215 Matched = Specialization;
5216 }
5217
5218 return Matched;
5219}
5220
Douglas Gregorcabea402009-09-22 15:41:20 +00005221/// \brief Add a single candidate to the overload set.
5222static void AddOverloadedCallCandidate(Sema &S,
John McCalld14a8642009-11-21 08:51:07 +00005223 NamedDecl *Callee,
John McCallb89836b2010-01-26 01:37:31 +00005224 AccessSpecifier Access,
John McCall6b51f282009-11-23 01:53:49 +00005225 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregorcabea402009-09-22 15:41:20 +00005226 Expr **Args, unsigned NumArgs,
5227 OverloadCandidateSet &CandidateSet,
5228 bool PartialOverloading) {
John McCalld14a8642009-11-21 08:51:07 +00005229 if (isa<UsingShadowDecl>(Callee))
5230 Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
5231
Douglas Gregorcabea402009-09-22 15:41:20 +00005232 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(Callee)) {
John McCall6b51f282009-11-23 01:53:49 +00005233 assert(!ExplicitTemplateArgs && "Explicit template arguments?");
John McCallb89836b2010-01-26 01:37:31 +00005234 S.AddOverloadCandidate(Func, Access, Args, NumArgs, CandidateSet,
5235 false, false, PartialOverloading);
Douglas Gregorcabea402009-09-22 15:41:20 +00005236 return;
John McCalld14a8642009-11-21 08:51:07 +00005237 }
5238
5239 if (FunctionTemplateDecl *FuncTemplate
5240 = dyn_cast<FunctionTemplateDecl>(Callee)) {
John McCallb89836b2010-01-26 01:37:31 +00005241 S.AddTemplateOverloadCandidate(FuncTemplate, Access, ExplicitTemplateArgs,
John McCalld14a8642009-11-21 08:51:07 +00005242 Args, NumArgs, CandidateSet);
John McCalld14a8642009-11-21 08:51:07 +00005243 return;
5244 }
5245
5246 assert(false && "unhandled case in overloaded call candidate");
5247
5248 // do nothing?
Douglas Gregorcabea402009-09-22 15:41:20 +00005249}
5250
5251/// \brief Add the overload candidates named by callee and/or found by argument
5252/// dependent lookup to the given overload set.
John McCall57500772009-12-16 12:17:52 +00005253void Sema::AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
Douglas Gregorcabea402009-09-22 15:41:20 +00005254 Expr **Args, unsigned NumArgs,
5255 OverloadCandidateSet &CandidateSet,
5256 bool PartialOverloading) {
John McCalld14a8642009-11-21 08:51:07 +00005257
5258#ifndef NDEBUG
5259 // Verify that ArgumentDependentLookup is consistent with the rules
5260 // in C++0x [basic.lookup.argdep]p3:
Douglas Gregorcabea402009-09-22 15:41:20 +00005261 //
Douglas Gregorcabea402009-09-22 15:41:20 +00005262 // Let X be the lookup set produced by unqualified lookup (3.4.1)
5263 // and let Y be the lookup set produced by argument dependent
5264 // lookup (defined as follows). If X contains
5265 //
5266 // -- a declaration of a class member, or
5267 //
5268 // -- a block-scope function declaration that is not a
John McCalld14a8642009-11-21 08:51:07 +00005269 // using-declaration, or
Douglas Gregorcabea402009-09-22 15:41:20 +00005270 //
5271 // -- a declaration that is neither a function or a function
5272 // template
5273 //
5274 // then Y is empty.
John McCalld14a8642009-11-21 08:51:07 +00005275
John McCall57500772009-12-16 12:17:52 +00005276 if (ULE->requiresADL()) {
5277 for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(),
5278 E = ULE->decls_end(); I != E; ++I) {
5279 assert(!(*I)->getDeclContext()->isRecord());
5280 assert(isa<UsingShadowDecl>(*I) ||
5281 !(*I)->getDeclContext()->isFunctionOrMethod());
5282 assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
John McCalld14a8642009-11-21 08:51:07 +00005283 }
5284 }
5285#endif
5286
John McCall57500772009-12-16 12:17:52 +00005287 // It would be nice to avoid this copy.
5288 TemplateArgumentListInfo TABuffer;
5289 const TemplateArgumentListInfo *ExplicitTemplateArgs = 0;
5290 if (ULE->hasExplicitTemplateArgs()) {
5291 ULE->copyTemplateArgumentsInto(TABuffer);
5292 ExplicitTemplateArgs = &TABuffer;
5293 }
5294
5295 for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(),
5296 E = ULE->decls_end(); I != E; ++I)
John McCallb89836b2010-01-26 01:37:31 +00005297 AddOverloadedCallCandidate(*this, *I, I.getAccess(), ExplicitTemplateArgs,
John McCalld14a8642009-11-21 08:51:07 +00005298 Args, NumArgs, CandidateSet,
Douglas Gregorcabea402009-09-22 15:41:20 +00005299 PartialOverloading);
John McCalld14a8642009-11-21 08:51:07 +00005300
John McCall57500772009-12-16 12:17:52 +00005301 if (ULE->requiresADL())
John McCall4c4c1df2010-01-26 03:27:55 +00005302 AddArgumentDependentLookupCandidates(ULE->getName(), /*Operator*/ false,
5303 Args, NumArgs,
Douglas Gregorcabea402009-09-22 15:41:20 +00005304 ExplicitTemplateArgs,
Douglas Gregorcabea402009-09-22 15:41:20 +00005305 CandidateSet,
5306 PartialOverloading);
5307}
John McCalld681c392009-12-16 08:11:27 +00005308
John McCall57500772009-12-16 12:17:52 +00005309static Sema::OwningExprResult Destroy(Sema &SemaRef, Expr *Fn,
5310 Expr **Args, unsigned NumArgs) {
5311 Fn->Destroy(SemaRef.Context);
5312 for (unsigned Arg = 0; Arg < NumArgs; ++Arg)
5313 Args[Arg]->Destroy(SemaRef.Context);
5314 return SemaRef.ExprError();
5315}
5316
John McCalld681c392009-12-16 08:11:27 +00005317/// Attempts to recover from a call where no functions were found.
5318///
5319/// Returns true if new candidates were found.
John McCall57500772009-12-16 12:17:52 +00005320static Sema::OwningExprResult
5321BuildRecoveryCallExpr(Sema &SemaRef, Expr *Fn,
5322 UnresolvedLookupExpr *ULE,
5323 SourceLocation LParenLoc,
5324 Expr **Args, unsigned NumArgs,
5325 SourceLocation *CommaLocs,
5326 SourceLocation RParenLoc) {
John McCalld681c392009-12-16 08:11:27 +00005327
5328 CXXScopeSpec SS;
5329 if (ULE->getQualifier()) {
5330 SS.setScopeRep(ULE->getQualifier());
5331 SS.setRange(ULE->getQualifierRange());
5332 }
5333
John McCall57500772009-12-16 12:17:52 +00005334 TemplateArgumentListInfo TABuffer;
5335 const TemplateArgumentListInfo *ExplicitTemplateArgs = 0;
5336 if (ULE->hasExplicitTemplateArgs()) {
5337 ULE->copyTemplateArgumentsInto(TABuffer);
5338 ExplicitTemplateArgs = &TABuffer;
5339 }
5340
John McCalld681c392009-12-16 08:11:27 +00005341 LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
5342 Sema::LookupOrdinaryName);
Douglas Gregor598b08f2009-12-31 05:20:13 +00005343 if (SemaRef.DiagnoseEmptyLookup(/*Scope=*/0, SS, R))
John McCall57500772009-12-16 12:17:52 +00005344 return Destroy(SemaRef, Fn, Args, NumArgs);
John McCalld681c392009-12-16 08:11:27 +00005345
John McCall57500772009-12-16 12:17:52 +00005346 assert(!R.empty() && "lookup results empty despite recovery");
5347
5348 // Build an implicit member call if appropriate. Just drop the
5349 // casts and such from the call, we don't really care.
5350 Sema::OwningExprResult NewFn = SemaRef.ExprError();
5351 if ((*R.begin())->isCXXClassMember())
5352 NewFn = SemaRef.BuildPossibleImplicitMemberExpr(SS, R, ExplicitTemplateArgs);
5353 else if (ExplicitTemplateArgs)
5354 NewFn = SemaRef.BuildTemplateIdExpr(SS, R, false, *ExplicitTemplateArgs);
5355 else
5356 NewFn = SemaRef.BuildDeclarationNameExpr(SS, R, false);
5357
5358 if (NewFn.isInvalid())
5359 return Destroy(SemaRef, Fn, Args, NumArgs);
5360
5361 Fn->Destroy(SemaRef.Context);
5362
5363 // This shouldn't cause an infinite loop because we're giving it
5364 // an expression with non-empty lookup results, which should never
5365 // end up here.
5366 return SemaRef.ActOnCallExpr(/*Scope*/ 0, move(NewFn), LParenLoc,
5367 Sema::MultiExprArg(SemaRef, (void**) Args, NumArgs),
5368 CommaLocs, RParenLoc);
John McCalld681c392009-12-16 08:11:27 +00005369}
Douglas Gregorcabea402009-09-22 15:41:20 +00005370
Douglas Gregor99dcbff2008-11-26 05:54:23 +00005371/// ResolveOverloadedCallFn - Given the call expression that calls Fn
Douglas Gregore254f902009-02-04 00:32:51 +00005372/// (which eventually refers to the declaration Func) and the call
5373/// arguments Args/NumArgs, attempt to resolve the function call down
5374/// to a specific function. If overload resolution succeeds, returns
5375/// the function declaration produced by overload
Douglas Gregora60a6912008-11-26 06:01:48 +00005376/// resolution. Otherwise, emits diagnostics, deletes all of the
Douglas Gregor99dcbff2008-11-26 05:54:23 +00005377/// arguments and Fn, and returns NULL.
John McCall57500772009-12-16 12:17:52 +00005378Sema::OwningExprResult
5379Sema::BuildOverloadedCallExpr(Expr *Fn, UnresolvedLookupExpr *ULE,
5380 SourceLocation LParenLoc,
5381 Expr **Args, unsigned NumArgs,
5382 SourceLocation *CommaLocs,
5383 SourceLocation RParenLoc) {
5384#ifndef NDEBUG
5385 if (ULE->requiresADL()) {
5386 // To do ADL, we must have found an unqualified name.
5387 assert(!ULE->getQualifier() && "qualified name with ADL");
5388
5389 // We don't perform ADL for implicit declarations of builtins.
5390 // Verify that this was correctly set up.
5391 FunctionDecl *F;
5392 if (ULE->decls_begin() + 1 == ULE->decls_end() &&
5393 (F = dyn_cast<FunctionDecl>(*ULE->decls_begin())) &&
5394 F->getBuiltinID() && F->isImplicit())
5395 assert(0 && "performing ADL for builtin");
5396
5397 // We don't perform ADL in C.
5398 assert(getLangOptions().CPlusPlus && "ADL enabled in C");
5399 }
5400#endif
5401
John McCallbc077cf2010-02-08 23:07:23 +00005402 OverloadCandidateSet CandidateSet(Fn->getExprLoc());
Douglas Gregorb8a9a412009-02-04 15:01:18 +00005403
John McCall57500772009-12-16 12:17:52 +00005404 // Add the functions denoted by the callee to the set of candidate
5405 // functions, including those from argument-dependent lookup.
5406 AddOverloadedCallCandidates(ULE, Args, NumArgs, CandidateSet);
John McCalld681c392009-12-16 08:11:27 +00005407
5408 // If we found nothing, try to recover.
5409 // AddRecoveryCallCandidates diagnoses the error itself, so we just
5410 // bailout out if it fails.
John McCall57500772009-12-16 12:17:52 +00005411 if (CandidateSet.empty())
5412 return BuildRecoveryCallExpr(*this, Fn, ULE, LParenLoc, Args, NumArgs,
5413 CommaLocs, RParenLoc);
John McCalld681c392009-12-16 08:11:27 +00005414
Douglas Gregor99dcbff2008-11-26 05:54:23 +00005415 OverloadCandidateSet::iterator Best;
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00005416 switch (BestViableFunction(CandidateSet, Fn->getLocStart(), Best)) {
John McCall57500772009-12-16 12:17:52 +00005417 case OR_Success: {
5418 FunctionDecl *FDecl = Best->Function;
John McCall58cc69d2010-01-27 01:50:18 +00005419 CheckUnresolvedLookupAccess(ULE, FDecl, Best->getAccess());
John McCall57500772009-12-16 12:17:52 +00005420 Fn = FixOverloadedFunctionReference(Fn, FDecl);
5421 return BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, NumArgs, RParenLoc);
5422 }
Douglas Gregor99dcbff2008-11-26 05:54:23 +00005423
5424 case OR_No_Viable_Function:
Chris Lattner45d9d602009-02-17 07:29:20 +00005425 Diag(Fn->getSourceRange().getBegin(),
Douglas Gregor99dcbff2008-11-26 05:54:23 +00005426 diag::err_ovl_no_viable_function_in_call)
John McCall57500772009-12-16 12:17:52 +00005427 << ULE->getName() << Fn->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00005428 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor99dcbff2008-11-26 05:54:23 +00005429 break;
5430
5431 case OR_Ambiguous:
5432 Diag(Fn->getSourceRange().getBegin(), diag::err_ovl_ambiguous_call)
John McCall57500772009-12-16 12:17:52 +00005433 << ULE->getName() << Fn->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00005434 PrintOverloadCandidates(CandidateSet, OCD_ViableCandidates, Args, NumArgs);
Douglas Gregor99dcbff2008-11-26 05:54:23 +00005435 break;
Douglas Gregor171c45a2009-02-18 21:56:37 +00005436
5437 case OR_Deleted:
5438 Diag(Fn->getSourceRange().getBegin(), diag::err_ovl_deleted_call)
5439 << Best->Function->isDeleted()
John McCall57500772009-12-16 12:17:52 +00005440 << ULE->getName()
Douglas Gregor171c45a2009-02-18 21:56:37 +00005441 << Fn->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00005442 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor171c45a2009-02-18 21:56:37 +00005443 break;
Douglas Gregor99dcbff2008-11-26 05:54:23 +00005444 }
5445
5446 // Overload resolution failed. Destroy all of the subexpressions and
5447 // return NULL.
5448 Fn->Destroy(Context);
5449 for (unsigned Arg = 0; Arg < NumArgs; ++Arg)
5450 Args[Arg]->Destroy(Context);
John McCall57500772009-12-16 12:17:52 +00005451 return ExprError();
Douglas Gregor99dcbff2008-11-26 05:54:23 +00005452}
5453
John McCall4c4c1df2010-01-26 03:27:55 +00005454static bool IsOverloaded(const UnresolvedSetImpl &Functions) {
John McCall283b9012009-11-22 00:44:51 +00005455 return Functions.size() > 1 ||
5456 (Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin()));
5457}
5458
Douglas Gregor084d8552009-03-13 23:49:33 +00005459/// \brief Create a unary operation that may resolve to an overloaded
5460/// operator.
5461///
5462/// \param OpLoc The location of the operator itself (e.g., '*').
5463///
5464/// \param OpcIn The UnaryOperator::Opcode that describes this
5465/// operator.
5466///
5467/// \param Functions The set of non-member functions that will be
5468/// considered by overload resolution. The caller needs to build this
5469/// set based on the context using, e.g.,
5470/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
5471/// set should not contain any member functions; those will be added
5472/// by CreateOverloadedUnaryOp().
5473///
5474/// \param input The input argument.
John McCall4c4c1df2010-01-26 03:27:55 +00005475Sema::OwningExprResult
5476Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, unsigned OpcIn,
5477 const UnresolvedSetImpl &Fns,
5478 ExprArg input) {
Douglas Gregor084d8552009-03-13 23:49:33 +00005479 UnaryOperator::Opcode Opc = static_cast<UnaryOperator::Opcode>(OpcIn);
5480 Expr *Input = (Expr *)input.get();
5481
5482 OverloadedOperatorKind Op = UnaryOperator::getOverloadedOperator(Opc);
5483 assert(Op != OO_None && "Invalid opcode for overloaded unary operator");
5484 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
5485
5486 Expr *Args[2] = { Input, 0 };
5487 unsigned NumArgs = 1;
Mike Stump11289f42009-09-09 15:08:12 +00005488
Douglas Gregor084d8552009-03-13 23:49:33 +00005489 // For post-increment and post-decrement, add the implicit '0' as
5490 // the second argument, so that we know this is a post-increment or
5491 // post-decrement.
5492 if (Opc == UnaryOperator::PostInc || Opc == UnaryOperator::PostDec) {
5493 llvm::APSInt Zero(Context.getTypeSize(Context.IntTy), false);
Mike Stump11289f42009-09-09 15:08:12 +00005494 Args[1] = new (Context) IntegerLiteral(Zero, Context.IntTy,
Douglas Gregor084d8552009-03-13 23:49:33 +00005495 SourceLocation());
5496 NumArgs = 2;
5497 }
5498
5499 if (Input->isTypeDependent()) {
John McCall58cc69d2010-01-27 01:50:18 +00005500 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators
John McCalld14a8642009-11-21 08:51:07 +00005501 UnresolvedLookupExpr *Fn
John McCall58cc69d2010-01-27 01:50:18 +00005502 = UnresolvedLookupExpr::Create(Context, /*Dependent*/ true, NamingClass,
John McCalle66edc12009-11-24 19:00:30 +00005503 0, SourceRange(), OpName, OpLoc,
John McCall4c4c1df2010-01-26 03:27:55 +00005504 /*ADL*/ true, IsOverloaded(Fns));
5505 Fn->addDecls(Fns.begin(), Fns.end());
Mike Stump11289f42009-09-09 15:08:12 +00005506
Douglas Gregor084d8552009-03-13 23:49:33 +00005507 input.release();
5508 return Owned(new (Context) CXXOperatorCallExpr(Context, Op, Fn,
5509 &Args[0], NumArgs,
5510 Context.DependentTy,
5511 OpLoc));
5512 }
5513
5514 // Build an empty overload set.
John McCallbc077cf2010-02-08 23:07:23 +00005515 OverloadCandidateSet CandidateSet(OpLoc);
Douglas Gregor084d8552009-03-13 23:49:33 +00005516
5517 // Add the candidates from the given function set.
John McCall4c4c1df2010-01-26 03:27:55 +00005518 AddFunctionCandidates(Fns, &Args[0], NumArgs, CandidateSet, false);
Douglas Gregor084d8552009-03-13 23:49:33 +00005519
5520 // Add operator candidates that are member functions.
5521 AddMemberOperatorCandidates(Op, OpLoc, &Args[0], NumArgs, CandidateSet);
5522
John McCall4c4c1df2010-01-26 03:27:55 +00005523 // Add candidates from ADL.
5524 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true,
Douglas Gregor6ec89d42010-02-05 05:15:43 +00005525 Args, NumArgs,
John McCall4c4c1df2010-01-26 03:27:55 +00005526 /*ExplicitTemplateArgs*/ 0,
5527 CandidateSet);
5528
Douglas Gregor084d8552009-03-13 23:49:33 +00005529 // Add builtin operator candidates.
Douglas Gregorc02cfe22009-10-21 23:19:44 +00005530 AddBuiltinOperatorCandidates(Op, OpLoc, &Args[0], NumArgs, CandidateSet);
Douglas Gregor084d8552009-03-13 23:49:33 +00005531
5532 // Perform overload resolution.
5533 OverloadCandidateSet::iterator Best;
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00005534 switch (BestViableFunction(CandidateSet, OpLoc, Best)) {
Douglas Gregor084d8552009-03-13 23:49:33 +00005535 case OR_Success: {
5536 // We found a built-in operator or an overloaded operator.
5537 FunctionDecl *FnDecl = Best->Function;
Mike Stump11289f42009-09-09 15:08:12 +00005538
Douglas Gregor084d8552009-03-13 23:49:33 +00005539 if (FnDecl) {
5540 // We matched an overloaded operator. Build a call to that
5541 // operator.
Mike Stump11289f42009-09-09 15:08:12 +00005542
Douglas Gregor084d8552009-03-13 23:49:33 +00005543 // Convert the arguments.
5544 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
John McCallb3a44002010-01-28 01:42:12 +00005545 CheckMemberOperatorAccess(OpLoc, Args[0], Method, Best->getAccess());
5546
Douglas Gregorcc3f3252010-03-03 23:55:11 +00005547 if (PerformObjectArgumentInitialization(Input, /*Qualifier=*/0, Method))
Douglas Gregor084d8552009-03-13 23:49:33 +00005548 return ExprError();
5549 } else {
5550 // Convert the arguments.
Douglas Gregore6600372009-12-23 17:40:29 +00005551 OwningExprResult InputInit
5552 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
Douglas Gregor8d48e9a2009-12-23 00:02:00 +00005553 FnDecl->getParamDecl(0)),
Douglas Gregore6600372009-12-23 17:40:29 +00005554 SourceLocation(),
5555 move(input));
5556 if (InputInit.isInvalid())
Douglas Gregor084d8552009-03-13 23:49:33 +00005557 return ExprError();
Douglas Gregor8d48e9a2009-12-23 00:02:00 +00005558
Douglas Gregore6600372009-12-23 17:40:29 +00005559 input = move(InputInit);
Douglas Gregor8d48e9a2009-12-23 00:02:00 +00005560 Input = (Expr *)input.get();
Douglas Gregor084d8552009-03-13 23:49:33 +00005561 }
5562
5563 // Determine the result type
Anders Carlssonf64a3da2009-10-13 21:19:37 +00005564 QualType ResultTy = FnDecl->getResultType().getNonReferenceType();
Mike Stump11289f42009-09-09 15:08:12 +00005565
Douglas Gregor084d8552009-03-13 23:49:33 +00005566 // Build the actual expression node.
5567 Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(),
5568 SourceLocation());
5569 UsualUnaryConversions(FnExpr);
Mike Stump11289f42009-09-09 15:08:12 +00005570
Douglas Gregor084d8552009-03-13 23:49:33 +00005571 input.release();
Eli Friedman030eee42009-11-18 03:58:17 +00005572 Args[0] = Input;
Anders Carlssonf64a3da2009-10-13 21:19:37 +00005573 ExprOwningPtr<CallExpr> TheCall(this,
5574 new (Context) CXXOperatorCallExpr(Context, Op, FnExpr,
Eli Friedman030eee42009-11-18 03:58:17 +00005575 Args, NumArgs, ResultTy, OpLoc));
Anders Carlssonf64a3da2009-10-13 21:19:37 +00005576
5577 if (CheckCallReturnType(FnDecl->getResultType(), OpLoc, TheCall.get(),
5578 FnDecl))
5579 return ExprError();
5580
5581 return MaybeBindToTemporary(TheCall.release());
Douglas Gregor084d8552009-03-13 23:49:33 +00005582 } else {
5583 // We matched a built-in operator. Convert the arguments, then
5584 // break out so that we will build the appropriate built-in
5585 // operator node.
5586 if (PerformImplicitConversion(Input, Best->BuiltinTypes.ParamTypes[0],
Douglas Gregor7c3bbdf2009-12-16 03:45:30 +00005587 Best->Conversions[0], AA_Passing))
Douglas Gregor084d8552009-03-13 23:49:33 +00005588 return ExprError();
5589
5590 break;
5591 }
5592 }
5593
5594 case OR_No_Viable_Function:
5595 // No viable function; fall through to handling this as a
5596 // built-in operator, which will produce an error message for us.
5597 break;
5598
5599 case OR_Ambiguous:
5600 Diag(OpLoc, diag::err_ovl_ambiguous_oper)
5601 << UnaryOperator::getOpcodeStr(Opc)
5602 << Input->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00005603 PrintOverloadCandidates(CandidateSet, OCD_ViableCandidates, Args, NumArgs,
Fariborz Jahaniane7196432009-10-12 20:11:40 +00005604 UnaryOperator::getOpcodeStr(Opc), OpLoc);
Douglas Gregor084d8552009-03-13 23:49:33 +00005605 return ExprError();
5606
5607 case OR_Deleted:
5608 Diag(OpLoc, diag::err_ovl_deleted_oper)
5609 << Best->Function->isDeleted()
5610 << UnaryOperator::getOpcodeStr(Opc)
5611 << Input->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00005612 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor084d8552009-03-13 23:49:33 +00005613 return ExprError();
5614 }
5615
5616 // Either we found no viable overloaded operator or we matched a
5617 // built-in operator. In either case, fall through to trying to
5618 // build a built-in operation.
5619 input.release();
5620 return CreateBuiltinUnaryOp(OpLoc, Opc, Owned(Input));
5621}
5622
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005623/// \brief Create a binary operation that may resolve to an overloaded
5624/// operator.
5625///
5626/// \param OpLoc The location of the operator itself (e.g., '+').
5627///
5628/// \param OpcIn The BinaryOperator::Opcode that describes this
5629/// operator.
5630///
5631/// \param Functions The set of non-member functions that will be
5632/// considered by overload resolution. The caller needs to build this
5633/// set based on the context using, e.g.,
5634/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
5635/// set should not contain any member functions; those will be added
5636/// by CreateOverloadedBinOp().
5637///
5638/// \param LHS Left-hand argument.
5639/// \param RHS Right-hand argument.
Mike Stump11289f42009-09-09 15:08:12 +00005640Sema::OwningExprResult
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005641Sema::CreateOverloadedBinOp(SourceLocation OpLoc,
Mike Stump11289f42009-09-09 15:08:12 +00005642 unsigned OpcIn,
John McCall4c4c1df2010-01-26 03:27:55 +00005643 const UnresolvedSetImpl &Fns,
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005644 Expr *LHS, Expr *RHS) {
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005645 Expr *Args[2] = { LHS, RHS };
Douglas Gregore9899d92009-08-26 17:08:25 +00005646 LHS=RHS=0; //Please use only Args instead of LHS/RHS couple
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005647
5648 BinaryOperator::Opcode Opc = static_cast<BinaryOperator::Opcode>(OpcIn);
5649 OverloadedOperatorKind Op = BinaryOperator::getOverloadedOperator(Opc);
5650 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
5651
5652 // If either side is type-dependent, create an appropriate dependent
5653 // expression.
Douglas Gregore9899d92009-08-26 17:08:25 +00005654 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
John McCall4c4c1df2010-01-26 03:27:55 +00005655 if (Fns.empty()) {
Douglas Gregor5287f092009-11-05 00:51:44 +00005656 // If there are no functions to store, just build a dependent
5657 // BinaryOperator or CompoundAssignment.
5658 if (Opc <= BinaryOperator::Assign || Opc > BinaryOperator::OrAssign)
5659 return Owned(new (Context) BinaryOperator(Args[0], Args[1], Opc,
5660 Context.DependentTy, OpLoc));
5661
5662 return Owned(new (Context) CompoundAssignOperator(Args[0], Args[1], Opc,
5663 Context.DependentTy,
5664 Context.DependentTy,
5665 Context.DependentTy,
5666 OpLoc));
5667 }
John McCall4c4c1df2010-01-26 03:27:55 +00005668
5669 // FIXME: save results of ADL from here?
John McCall58cc69d2010-01-27 01:50:18 +00005670 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators
John McCalld14a8642009-11-21 08:51:07 +00005671 UnresolvedLookupExpr *Fn
John McCall58cc69d2010-01-27 01:50:18 +00005672 = UnresolvedLookupExpr::Create(Context, /*Dependent*/ true, NamingClass,
John McCalle66edc12009-11-24 19:00:30 +00005673 0, SourceRange(), OpName, OpLoc,
John McCall4c4c1df2010-01-26 03:27:55 +00005674 /*ADL*/ true, IsOverloaded(Fns));
Mike Stump11289f42009-09-09 15:08:12 +00005675
John McCall4c4c1df2010-01-26 03:27:55 +00005676 Fn->addDecls(Fns.begin(), Fns.end());
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005677 return Owned(new (Context) CXXOperatorCallExpr(Context, Op, Fn,
Mike Stump11289f42009-09-09 15:08:12 +00005678 Args, 2,
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005679 Context.DependentTy,
5680 OpLoc));
5681 }
5682
5683 // If this is the .* operator, which is not overloadable, just
5684 // create a built-in binary operator.
5685 if (Opc == BinaryOperator::PtrMemD)
Douglas Gregore9899d92009-08-26 17:08:25 +00005686 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005687
Sebastian Redl6a96bf72009-11-18 23:10:33 +00005688 // If this is the assignment operator, we only perform overload resolution
5689 // if the left-hand side is a class or enumeration type. This is actually
5690 // a hack. The standard requires that we do overload resolution between the
5691 // various built-in candidates, but as DR507 points out, this can lead to
5692 // problems. So we do it this way, which pretty much follows what GCC does.
5693 // Note that we go the traditional code path for compound assignment forms.
5694 if (Opc==BinaryOperator::Assign && !Args[0]->getType()->isOverloadableType())
Douglas Gregore9899d92009-08-26 17:08:25 +00005695 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005696
Douglas Gregor084d8552009-03-13 23:49:33 +00005697 // Build an empty overload set.
John McCallbc077cf2010-02-08 23:07:23 +00005698 OverloadCandidateSet CandidateSet(OpLoc);
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005699
5700 // Add the candidates from the given function set.
John McCall4c4c1df2010-01-26 03:27:55 +00005701 AddFunctionCandidates(Fns, Args, 2, CandidateSet, false);
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005702
5703 // Add operator candidates that are member functions.
5704 AddMemberOperatorCandidates(Op, OpLoc, Args, 2, CandidateSet);
5705
John McCall4c4c1df2010-01-26 03:27:55 +00005706 // Add candidates from ADL.
5707 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true,
5708 Args, 2,
5709 /*ExplicitTemplateArgs*/ 0,
5710 CandidateSet);
5711
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005712 // Add builtin operator candidates.
Douglas Gregorc02cfe22009-10-21 23:19:44 +00005713 AddBuiltinOperatorCandidates(Op, OpLoc, Args, 2, CandidateSet);
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005714
5715 // Perform overload resolution.
5716 OverloadCandidateSet::iterator Best;
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00005717 switch (BestViableFunction(CandidateSet, OpLoc, Best)) {
Sebastian Redl1a99f442009-04-16 17:51:27 +00005718 case OR_Success: {
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005719 // We found a built-in operator or an overloaded operator.
5720 FunctionDecl *FnDecl = Best->Function;
5721
5722 if (FnDecl) {
5723 // We matched an overloaded operator. Build a call to that
5724 // operator.
5725
5726 // Convert the arguments.
5727 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
John McCallb3a44002010-01-28 01:42:12 +00005728 // Best->Access is only meaningful for class members.
5729 CheckMemberOperatorAccess(OpLoc, Args[0], Method, Best->getAccess());
5730
Douglas Gregor0a70c4d2009-12-22 21:44:34 +00005731 OwningExprResult Arg1
5732 = PerformCopyInitialization(
5733 InitializedEntity::InitializeParameter(
5734 FnDecl->getParamDecl(0)),
5735 SourceLocation(),
5736 Owned(Args[1]));
5737 if (Arg1.isInvalid())
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005738 return ExprError();
Douglas Gregor0a70c4d2009-12-22 21:44:34 +00005739
Douglas Gregorcc3f3252010-03-03 23:55:11 +00005740 if (PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/0,
5741 Method))
Douglas Gregor0a70c4d2009-12-22 21:44:34 +00005742 return ExprError();
5743
5744 Args[1] = RHS = Arg1.takeAs<Expr>();
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005745 } else {
5746 // Convert the arguments.
Douglas Gregor0a70c4d2009-12-22 21:44:34 +00005747 OwningExprResult Arg0
5748 = PerformCopyInitialization(
5749 InitializedEntity::InitializeParameter(
5750 FnDecl->getParamDecl(0)),
5751 SourceLocation(),
5752 Owned(Args[0]));
5753 if (Arg0.isInvalid())
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005754 return ExprError();
Douglas Gregor0a70c4d2009-12-22 21:44:34 +00005755
5756 OwningExprResult Arg1
5757 = PerformCopyInitialization(
5758 InitializedEntity::InitializeParameter(
5759 FnDecl->getParamDecl(1)),
5760 SourceLocation(),
5761 Owned(Args[1]));
5762 if (Arg1.isInvalid())
5763 return ExprError();
5764 Args[0] = LHS = Arg0.takeAs<Expr>();
5765 Args[1] = RHS = Arg1.takeAs<Expr>();
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005766 }
5767
5768 // Determine the result type
5769 QualType ResultTy
John McCall9dd450b2009-09-21 23:43:11 +00005770 = FnDecl->getType()->getAs<FunctionType>()->getResultType();
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005771 ResultTy = ResultTy.getNonReferenceType();
5772
5773 // Build the actual expression node.
5774 Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(),
Argyrios Kyrtzidisef1c1e52009-07-14 03:19:38 +00005775 OpLoc);
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005776 UsualUnaryConversions(FnExpr);
5777
Anders Carlssone4f4b5e2009-10-13 22:43:21 +00005778 ExprOwningPtr<CXXOperatorCallExpr>
5779 TheCall(this, new (Context) CXXOperatorCallExpr(Context, Op, FnExpr,
5780 Args, 2, ResultTy,
5781 OpLoc));
5782
5783 if (CheckCallReturnType(FnDecl->getResultType(), OpLoc, TheCall.get(),
5784 FnDecl))
5785 return ExprError();
5786
5787 return MaybeBindToTemporary(TheCall.release());
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005788 } else {
5789 // We matched a built-in operator. Convert the arguments, then
5790 // break out so that we will build the appropriate built-in
5791 // operator node.
Douglas Gregore9899d92009-08-26 17:08:25 +00005792 if (PerformImplicitConversion(Args[0], Best->BuiltinTypes.ParamTypes[0],
Douglas Gregor7c3bbdf2009-12-16 03:45:30 +00005793 Best->Conversions[0], AA_Passing) ||
Douglas Gregore9899d92009-08-26 17:08:25 +00005794 PerformImplicitConversion(Args[1], Best->BuiltinTypes.ParamTypes[1],
Douglas Gregor7c3bbdf2009-12-16 03:45:30 +00005795 Best->Conversions[1], AA_Passing))
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005796 return ExprError();
5797
5798 break;
5799 }
5800 }
5801
Douglas Gregor66950a32009-09-30 21:46:01 +00005802 case OR_No_Viable_Function: {
5803 // C++ [over.match.oper]p9:
5804 // If the operator is the operator , [...] and there are no
5805 // viable functions, then the operator is assumed to be the
5806 // built-in operator and interpreted according to clause 5.
5807 if (Opc == BinaryOperator::Comma)
5808 break;
5809
Sebastian Redl027de2a2009-05-21 11:50:50 +00005810 // For class as left operand for assignment or compound assigment operator
5811 // do not fall through to handling in built-in, but report that no overloaded
5812 // assignment operator found
Douglas Gregor66950a32009-09-30 21:46:01 +00005813 OwningExprResult Result = ExprError();
5814 if (Args[0]->getType()->isRecordType() &&
5815 Opc >= BinaryOperator::Assign && Opc <= BinaryOperator::OrAssign) {
Sebastian Redl027de2a2009-05-21 11:50:50 +00005816 Diag(OpLoc, diag::err_ovl_no_viable_oper)
5817 << BinaryOperator::getOpcodeStr(Opc)
Douglas Gregore9899d92009-08-26 17:08:25 +00005818 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
Douglas Gregor66950a32009-09-30 21:46:01 +00005819 } else {
5820 // No viable function; try to create a built-in operation, which will
5821 // produce an error. Then, show the non-viable candidates.
5822 Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
Sebastian Redl027de2a2009-05-21 11:50:50 +00005823 }
Douglas Gregor66950a32009-09-30 21:46:01 +00005824 assert(Result.isInvalid() &&
5825 "C++ binary operator overloading is missing candidates!");
5826 if (Result.isInvalid())
John McCallad907772010-01-12 07:18:19 +00005827 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, 2,
Fariborz Jahaniane7196432009-10-12 20:11:40 +00005828 BinaryOperator::getOpcodeStr(Opc), OpLoc);
Douglas Gregor66950a32009-09-30 21:46:01 +00005829 return move(Result);
5830 }
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005831
5832 case OR_Ambiguous:
5833 Diag(OpLoc, diag::err_ovl_ambiguous_oper)
5834 << BinaryOperator::getOpcodeStr(Opc)
Douglas Gregore9899d92009-08-26 17:08:25 +00005835 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00005836 PrintOverloadCandidates(CandidateSet, OCD_ViableCandidates, Args, 2,
Fariborz Jahaniane7196432009-10-12 20:11:40 +00005837 BinaryOperator::getOpcodeStr(Opc), OpLoc);
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005838 return ExprError();
5839
5840 case OR_Deleted:
5841 Diag(OpLoc, diag::err_ovl_deleted_oper)
5842 << Best->Function->isDeleted()
5843 << BinaryOperator::getOpcodeStr(Opc)
Douglas Gregore9899d92009-08-26 17:08:25 +00005844 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00005845 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, 2);
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005846 return ExprError();
John McCall0d1da222010-01-12 00:44:57 +00005847 }
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005848
Douglas Gregor66950a32009-09-30 21:46:01 +00005849 // We matched a built-in operator; build it.
Douglas Gregore9899d92009-08-26 17:08:25 +00005850 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
Douglas Gregor1baf54e2009-03-13 18:40:31 +00005851}
5852
Sebastian Redladba46e2009-10-29 20:17:01 +00005853Action::OwningExprResult
5854Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
5855 SourceLocation RLoc,
5856 ExprArg Base, ExprArg Idx) {
5857 Expr *Args[2] = { static_cast<Expr*>(Base.get()),
5858 static_cast<Expr*>(Idx.get()) };
5859 DeclarationName OpName =
5860 Context.DeclarationNames.getCXXOperatorName(OO_Subscript);
5861
5862 // If either side is type-dependent, create an appropriate dependent
5863 // expression.
5864 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
5865
John McCall58cc69d2010-01-27 01:50:18 +00005866 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators
John McCalld14a8642009-11-21 08:51:07 +00005867 UnresolvedLookupExpr *Fn
John McCall58cc69d2010-01-27 01:50:18 +00005868 = UnresolvedLookupExpr::Create(Context, /*Dependent*/ true, NamingClass,
John McCalle66edc12009-11-24 19:00:30 +00005869 0, SourceRange(), OpName, LLoc,
John McCall283b9012009-11-22 00:44:51 +00005870 /*ADL*/ true, /*Overloaded*/ false);
John McCalle66edc12009-11-24 19:00:30 +00005871 // Can't add any actual overloads yet
Sebastian Redladba46e2009-10-29 20:17:01 +00005872
5873 Base.release();
5874 Idx.release();
5875 return Owned(new (Context) CXXOperatorCallExpr(Context, OO_Subscript, Fn,
5876 Args, 2,
5877 Context.DependentTy,
5878 RLoc));
5879 }
5880
5881 // Build an empty overload set.
John McCallbc077cf2010-02-08 23:07:23 +00005882 OverloadCandidateSet CandidateSet(LLoc);
Sebastian Redladba46e2009-10-29 20:17:01 +00005883
5884 // Subscript can only be overloaded as a member function.
5885
5886 // Add operator candidates that are member functions.
5887 AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, 2, CandidateSet);
5888
5889 // Add builtin operator candidates.
5890 AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, 2, CandidateSet);
5891
5892 // Perform overload resolution.
5893 OverloadCandidateSet::iterator Best;
5894 switch (BestViableFunction(CandidateSet, LLoc, Best)) {
5895 case OR_Success: {
5896 // We found a built-in operator or an overloaded operator.
5897 FunctionDecl *FnDecl = Best->Function;
5898
5899 if (FnDecl) {
5900 // We matched an overloaded operator. Build a call to that
5901 // operator.
5902
John McCallb3a44002010-01-28 01:42:12 +00005903 CheckMemberOperatorAccess(LLoc, Args[0], FnDecl, Best->getAccess());
John McCall58cc69d2010-01-27 01:50:18 +00005904
Sebastian Redladba46e2009-10-29 20:17:01 +00005905 // Convert the arguments.
5906 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
Douglas Gregorcc3f3252010-03-03 23:55:11 +00005907 if (PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/0,
5908 Method))
Sebastian Redladba46e2009-10-29 20:17:01 +00005909 return ExprError();
5910
Anders Carlssona68e51e2010-01-29 18:37:50 +00005911 // Convert the arguments.
5912 OwningExprResult InputInit
5913 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
5914 FnDecl->getParamDecl(0)),
5915 SourceLocation(),
5916 Owned(Args[1]));
5917 if (InputInit.isInvalid())
5918 return ExprError();
5919
5920 Args[1] = InputInit.takeAs<Expr>();
5921
Sebastian Redladba46e2009-10-29 20:17:01 +00005922 // Determine the result type
5923 QualType ResultTy
5924 = FnDecl->getType()->getAs<FunctionType>()->getResultType();
5925 ResultTy = ResultTy.getNonReferenceType();
5926
5927 // Build the actual expression node.
5928 Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(),
5929 LLoc);
5930 UsualUnaryConversions(FnExpr);
5931
5932 Base.release();
5933 Idx.release();
5934 ExprOwningPtr<CXXOperatorCallExpr>
5935 TheCall(this, new (Context) CXXOperatorCallExpr(Context, OO_Subscript,
5936 FnExpr, Args, 2,
5937 ResultTy, RLoc));
5938
5939 if (CheckCallReturnType(FnDecl->getResultType(), LLoc, TheCall.get(),
5940 FnDecl))
5941 return ExprError();
5942
5943 return MaybeBindToTemporary(TheCall.release());
5944 } else {
5945 // We matched a built-in operator. Convert the arguments, then
5946 // break out so that we will build the appropriate built-in
5947 // operator node.
5948 if (PerformImplicitConversion(Args[0], Best->BuiltinTypes.ParamTypes[0],
Douglas Gregor7c3bbdf2009-12-16 03:45:30 +00005949 Best->Conversions[0], AA_Passing) ||
Sebastian Redladba46e2009-10-29 20:17:01 +00005950 PerformImplicitConversion(Args[1], Best->BuiltinTypes.ParamTypes[1],
Douglas Gregor7c3bbdf2009-12-16 03:45:30 +00005951 Best->Conversions[1], AA_Passing))
Sebastian Redladba46e2009-10-29 20:17:01 +00005952 return ExprError();
5953
5954 break;
5955 }
5956 }
5957
5958 case OR_No_Viable_Function: {
John McCall02374852010-01-07 02:04:15 +00005959 if (CandidateSet.empty())
5960 Diag(LLoc, diag::err_ovl_no_oper)
5961 << Args[0]->getType() << /*subscript*/ 0
5962 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
5963 else
5964 Diag(LLoc, diag::err_ovl_no_viable_subscript)
5965 << Args[0]->getType()
5966 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00005967 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, 2,
John McCall02374852010-01-07 02:04:15 +00005968 "[]", LLoc);
5969 return ExprError();
Sebastian Redladba46e2009-10-29 20:17:01 +00005970 }
5971
5972 case OR_Ambiguous:
5973 Diag(LLoc, diag::err_ovl_ambiguous_oper)
5974 << "[]" << Args[0]->getSourceRange() << Args[1]->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00005975 PrintOverloadCandidates(CandidateSet, OCD_ViableCandidates, Args, 2,
Sebastian Redladba46e2009-10-29 20:17:01 +00005976 "[]", LLoc);
5977 return ExprError();
5978
5979 case OR_Deleted:
5980 Diag(LLoc, diag::err_ovl_deleted_oper)
5981 << Best->Function->isDeleted() << "[]"
5982 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00005983 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, 2,
John McCall12f97bc2010-01-08 04:41:39 +00005984 "[]", LLoc);
Sebastian Redladba46e2009-10-29 20:17:01 +00005985 return ExprError();
5986 }
5987
5988 // We matched a built-in operator; build it.
5989 Base.release();
5990 Idx.release();
5991 return CreateBuiltinArraySubscriptExpr(Owned(Args[0]), LLoc,
5992 Owned(Args[1]), RLoc);
5993}
5994
Douglas Gregor97fd6e22008-12-22 05:46:06 +00005995/// BuildCallToMemberFunction - Build a call to a member
5996/// function. MemExpr is the expression that refers to the member
5997/// function (and includes the object parameter), Args/NumArgs are the
5998/// arguments to the function call (not including the object
5999/// parameter). The caller needs to validate that the member
6000/// expression refers to a member function or an overloaded member
6001/// function.
John McCall2d74de92009-12-01 22:10:20 +00006002Sema::OwningExprResult
Mike Stump11289f42009-09-09 15:08:12 +00006003Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE,
6004 SourceLocation LParenLoc, Expr **Args,
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006005 unsigned NumArgs, SourceLocation *CommaLocs,
6006 SourceLocation RParenLoc) {
6007 // Dig out the member expression. This holds both the object
6008 // argument and the member function we're referring to.
John McCall10eae182009-11-30 22:42:35 +00006009 Expr *NakedMemExpr = MemExprE->IgnoreParens();
6010
John McCall10eae182009-11-30 22:42:35 +00006011 MemberExpr *MemExpr;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006012 CXXMethodDecl *Method = 0;
Douglas Gregorcc3f3252010-03-03 23:55:11 +00006013 NestedNameSpecifier *Qualifier = 0;
John McCall10eae182009-11-30 22:42:35 +00006014 if (isa<MemberExpr>(NakedMemExpr)) {
6015 MemExpr = cast<MemberExpr>(NakedMemExpr);
John McCall10eae182009-11-30 22:42:35 +00006016 Method = cast<CXXMethodDecl>(MemExpr->getMemberDecl());
Douglas Gregorcc3f3252010-03-03 23:55:11 +00006017 Qualifier = MemExpr->getQualifier();
John McCall10eae182009-11-30 22:42:35 +00006018 } else {
6019 UnresolvedMemberExpr *UnresExpr = cast<UnresolvedMemberExpr>(NakedMemExpr);
Douglas Gregorcc3f3252010-03-03 23:55:11 +00006020 Qualifier = UnresExpr->getQualifier();
6021
John McCall6e9f8f62009-12-03 04:06:58 +00006022 QualType ObjectType = UnresExpr->getBaseType();
John McCall10eae182009-11-30 22:42:35 +00006023
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006024 // Add overload candidates
John McCallbc077cf2010-02-08 23:07:23 +00006025 OverloadCandidateSet CandidateSet(UnresExpr->getMemberLoc());
Mike Stump11289f42009-09-09 15:08:12 +00006026
John McCall2d74de92009-12-01 22:10:20 +00006027 // FIXME: avoid copy.
6028 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0;
6029 if (UnresExpr->hasExplicitTemplateArgs()) {
6030 UnresExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
6031 TemplateArgs = &TemplateArgsBuffer;
6032 }
6033
John McCall10eae182009-11-30 22:42:35 +00006034 for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(),
6035 E = UnresExpr->decls_end(); I != E; ++I) {
6036
John McCall6e9f8f62009-12-03 04:06:58 +00006037 NamedDecl *Func = *I;
6038 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(Func->getDeclContext());
6039 if (isa<UsingShadowDecl>(Func))
6040 Func = cast<UsingShadowDecl>(Func)->getTargetDecl();
6041
John McCall10eae182009-11-30 22:42:35 +00006042 if ((Method = dyn_cast<CXXMethodDecl>(Func))) {
Douglas Gregord3319842009-10-24 04:59:53 +00006043 // If explicit template arguments were provided, we can't call a
6044 // non-template member function.
John McCall2d74de92009-12-01 22:10:20 +00006045 if (TemplateArgs)
Douglas Gregord3319842009-10-24 04:59:53 +00006046 continue;
6047
John McCallb89836b2010-01-26 01:37:31 +00006048 AddMethodCandidate(Method, I.getAccess(), ActingDC, ObjectType,
6049 Args, NumArgs,
John McCall6e9f8f62009-12-03 04:06:58 +00006050 CandidateSet, /*SuppressUserConversions=*/false);
John McCall6b51f282009-11-23 01:53:49 +00006051 } else {
John McCall10eae182009-11-30 22:42:35 +00006052 AddMethodTemplateCandidate(cast<FunctionTemplateDecl>(Func),
John McCallb89836b2010-01-26 01:37:31 +00006053 I.getAccess(), ActingDC, TemplateArgs,
John McCall6e9f8f62009-12-03 04:06:58 +00006054 ObjectType, Args, NumArgs,
Douglas Gregor5ed5ae42009-08-21 18:42:58 +00006055 CandidateSet,
6056 /*SuppressUsedConversions=*/false);
John McCall6b51f282009-11-23 01:53:49 +00006057 }
Douglas Gregor5ed5ae42009-08-21 18:42:58 +00006058 }
Mike Stump11289f42009-09-09 15:08:12 +00006059
John McCall10eae182009-11-30 22:42:35 +00006060 DeclarationName DeclName = UnresExpr->getMemberName();
6061
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006062 OverloadCandidateSet::iterator Best;
John McCall10eae182009-11-30 22:42:35 +00006063 switch (BestViableFunction(CandidateSet, UnresExpr->getLocStart(), Best)) {
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006064 case OR_Success:
6065 Method = cast<CXXMethodDecl>(Best->Function);
John McCall58cc69d2010-01-27 01:50:18 +00006066 CheckUnresolvedMemberAccess(UnresExpr, Method, Best->getAccess());
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006067 break;
6068
6069 case OR_No_Viable_Function:
John McCall10eae182009-11-30 22:42:35 +00006070 Diag(UnresExpr->getMemberLoc(),
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006071 diag::err_ovl_no_viable_member_function_in_call)
Douglas Gregor97628d62009-08-21 00:16:32 +00006072 << DeclName << MemExprE->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00006073 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006074 // FIXME: Leaking incoming expressions!
John McCall2d74de92009-12-01 22:10:20 +00006075 return ExprError();
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006076
6077 case OR_Ambiguous:
John McCall10eae182009-11-30 22:42:35 +00006078 Diag(UnresExpr->getMemberLoc(), diag::err_ovl_ambiguous_member_call)
Douglas Gregor97628d62009-08-21 00:16:32 +00006079 << DeclName << MemExprE->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00006080 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006081 // FIXME: Leaking incoming expressions!
John McCall2d74de92009-12-01 22:10:20 +00006082 return ExprError();
Douglas Gregor171c45a2009-02-18 21:56:37 +00006083
6084 case OR_Deleted:
John McCall10eae182009-11-30 22:42:35 +00006085 Diag(UnresExpr->getMemberLoc(), diag::err_ovl_deleted_member_call)
Douglas Gregor171c45a2009-02-18 21:56:37 +00006086 << Best->Function->isDeleted()
Douglas Gregor97628d62009-08-21 00:16:32 +00006087 << DeclName << MemExprE->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00006088 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor171c45a2009-02-18 21:56:37 +00006089 // FIXME: Leaking incoming expressions!
John McCall2d74de92009-12-01 22:10:20 +00006090 return ExprError();
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006091 }
6092
Douglas Gregor51c538b2009-11-20 19:42:02 +00006093 MemExprE = FixOverloadedFunctionReference(MemExprE, Method);
John McCall2d74de92009-12-01 22:10:20 +00006094
John McCall2d74de92009-12-01 22:10:20 +00006095 // If overload resolution picked a static member, build a
6096 // non-member call based on that function.
6097 if (Method->isStatic()) {
6098 return BuildResolvedCallExpr(MemExprE, Method, LParenLoc,
6099 Args, NumArgs, RParenLoc);
6100 }
6101
John McCall10eae182009-11-30 22:42:35 +00006102 MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens());
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006103 }
6104
6105 assert(Method && "Member call to something that isn't a method?");
Mike Stump11289f42009-09-09 15:08:12 +00006106 ExprOwningPtr<CXXMemberCallExpr>
John McCall2d74de92009-12-01 22:10:20 +00006107 TheCall(this, new (Context) CXXMemberCallExpr(Context, MemExprE, Args,
Mike Stump11289f42009-09-09 15:08:12 +00006108 NumArgs,
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006109 Method->getResultType().getNonReferenceType(),
6110 RParenLoc));
6111
Anders Carlssonc4859ba2009-10-10 00:06:20 +00006112 // Check for a valid return type.
6113 if (CheckCallReturnType(Method->getResultType(), MemExpr->getMemberLoc(),
6114 TheCall.get(), Method))
John McCall2d74de92009-12-01 22:10:20 +00006115 return ExprError();
Anders Carlssonc4859ba2009-10-10 00:06:20 +00006116
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006117 // Convert the object argument (for a non-static member function call).
John McCall2d74de92009-12-01 22:10:20 +00006118 Expr *ObjectArg = MemExpr->getBase();
Mike Stump11289f42009-09-09 15:08:12 +00006119 if (!Method->isStatic() &&
Douglas Gregorcc3f3252010-03-03 23:55:11 +00006120 PerformObjectArgumentInitialization(ObjectArg, Qualifier, Method))
John McCall2d74de92009-12-01 22:10:20 +00006121 return ExprError();
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006122 MemExpr->setBase(ObjectArg);
6123
6124 // Convert the rest of the arguments
Douglas Gregordeaad8c2009-02-26 23:50:07 +00006125 const FunctionProtoType *Proto = cast<FunctionProtoType>(Method->getType());
Mike Stump11289f42009-09-09 15:08:12 +00006126 if (ConvertArgumentsForCall(&*TheCall, MemExpr, Method, Proto, Args, NumArgs,
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006127 RParenLoc))
John McCall2d74de92009-12-01 22:10:20 +00006128 return ExprError();
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006129
Anders Carlssonbc4c1072009-08-16 01:56:34 +00006130 if (CheckFunctionCall(Method, TheCall.get()))
John McCall2d74de92009-12-01 22:10:20 +00006131 return ExprError();
Anders Carlsson8c84c202009-08-16 03:42:12 +00006132
John McCall2d74de92009-12-01 22:10:20 +00006133 return MaybeBindToTemporary(TheCall.release());
Douglas Gregor97fd6e22008-12-22 05:46:06 +00006134}
6135
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006136/// BuildCallToObjectOfClassType - Build a call to an object of class
6137/// type (C++ [over.call.object]), which can end up invoking an
6138/// overloaded function call operator (@c operator()) or performing a
6139/// user-defined conversion on the object argument.
Mike Stump11289f42009-09-09 15:08:12 +00006140Sema::ExprResult
6141Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Object,
Douglas Gregorb0846b02008-12-06 00:22:45 +00006142 SourceLocation LParenLoc,
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006143 Expr **Args, unsigned NumArgs,
Mike Stump11289f42009-09-09 15:08:12 +00006144 SourceLocation *CommaLocs,
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006145 SourceLocation RParenLoc) {
6146 assert(Object->getType()->isRecordType() && "Requires object type argument");
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006147 const RecordType *Record = Object->getType()->getAs<RecordType>();
Mike Stump11289f42009-09-09 15:08:12 +00006148
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006149 // C++ [over.call.object]p1:
6150 // If the primary-expression E in the function call syntax
Eli Friedman44b83ee2009-08-05 19:21:58 +00006151 // evaluates to a class object of type "cv T", then the set of
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006152 // candidate functions includes at least the function call
6153 // operators of T. The function call operators of T are obtained by
6154 // ordinary lookup of the name operator() in the context of
6155 // (E).operator().
John McCallbc077cf2010-02-08 23:07:23 +00006156 OverloadCandidateSet CandidateSet(LParenLoc);
Douglas Gregor91f84212008-12-11 16:49:14 +00006157 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Call);
Douglas Gregorc473cbb2009-11-15 07:48:03 +00006158
6159 if (RequireCompleteType(LParenLoc, Object->getType(),
6160 PartialDiagnostic(diag::err_incomplete_object_call)
6161 << Object->getSourceRange()))
6162 return true;
6163
John McCall27b18f82009-11-17 02:14:36 +00006164 LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName);
6165 LookupQualifiedName(R, Record->getDecl());
6166 R.suppressDiagnostics();
6167
Douglas Gregorc473cbb2009-11-15 07:48:03 +00006168 for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
Douglas Gregor358e7742009-11-07 17:23:56 +00006169 Oper != OperEnd; ++Oper) {
John McCallb89836b2010-01-26 01:37:31 +00006170 AddMethodCandidate(*Oper, Oper.getAccess(), Object->getType(),
6171 Args, NumArgs, CandidateSet,
John McCallf0f1cf02009-11-17 07:50:12 +00006172 /*SuppressUserConversions=*/ false);
Douglas Gregor358e7742009-11-07 17:23:56 +00006173 }
Douglas Gregor74ba25c2009-10-21 06:18:39 +00006174
Douglas Gregorab7897a2008-11-19 22:57:39 +00006175 // C++ [over.call.object]p2:
6176 // In addition, for each conversion function declared in T of the
6177 // form
6178 //
6179 // operator conversion-type-id () cv-qualifier;
6180 //
6181 // where cv-qualifier is the same cv-qualification as, or a
6182 // greater cv-qualification than, cv, and where conversion-type-id
Douglas Gregorf49fdf82008-11-20 13:33:37 +00006183 // denotes the type "pointer to function of (P1,...,Pn) returning
6184 // R", or the type "reference to pointer to function of
6185 // (P1,...,Pn) returning R", or the type "reference to function
6186 // of (P1,...,Pn) returning R", a surrogate call function [...]
Douglas Gregorab7897a2008-11-19 22:57:39 +00006187 // is also considered as a candidate function. Similarly,
6188 // surrogate call functions are added to the set of candidate
6189 // functions for each conversion function declared in an
6190 // accessible base class provided the function is not hidden
6191 // within T by another intervening declaration.
John McCallad371252010-01-20 00:46:10 +00006192 const UnresolvedSetImpl *Conversions
Douglas Gregor21591822010-01-11 19:36:35 +00006193 = cast<CXXRecordDecl>(Record->getDecl())->getVisibleConversionFunctions();
John McCallad371252010-01-20 00:46:10 +00006194 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
John McCalld14a8642009-11-21 08:51:07 +00006195 E = Conversions->end(); I != E; ++I) {
John McCall6e9f8f62009-12-03 04:06:58 +00006196 NamedDecl *D = *I;
6197 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
6198 if (isa<UsingShadowDecl>(D))
6199 D = cast<UsingShadowDecl>(D)->getTargetDecl();
6200
Douglas Gregor74ba25c2009-10-21 06:18:39 +00006201 // Skip over templated conversion functions; they aren't
6202 // surrogates.
John McCall6e9f8f62009-12-03 04:06:58 +00006203 if (isa<FunctionTemplateDecl>(D))
Douglas Gregor74ba25c2009-10-21 06:18:39 +00006204 continue;
Douglas Gregor05155d82009-08-21 23:19:43 +00006205
John McCall6e9f8f62009-12-03 04:06:58 +00006206 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
John McCalld14a8642009-11-21 08:51:07 +00006207
Douglas Gregor74ba25c2009-10-21 06:18:39 +00006208 // Strip the reference type (if any) and then the pointer type (if
6209 // any) to get down to what might be a function type.
6210 QualType ConvType = Conv->getConversionType().getNonReferenceType();
6211 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
6212 ConvType = ConvPtrType->getPointeeType();
Douglas Gregorab7897a2008-11-19 22:57:39 +00006213
Douglas Gregor74ba25c2009-10-21 06:18:39 +00006214 if (const FunctionProtoType *Proto = ConvType->getAs<FunctionProtoType>())
John McCallb89836b2010-01-26 01:37:31 +00006215 AddSurrogateCandidate(Conv, I.getAccess(), ActingContext, Proto,
John McCall6e9f8f62009-12-03 04:06:58 +00006216 Object->getType(), Args, NumArgs,
6217 CandidateSet);
Douglas Gregorab7897a2008-11-19 22:57:39 +00006218 }
Mike Stump11289f42009-09-09 15:08:12 +00006219
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006220 // Perform overload resolution.
6221 OverloadCandidateSet::iterator Best;
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00006222 switch (BestViableFunction(CandidateSet, Object->getLocStart(), Best)) {
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006223 case OR_Success:
Douglas Gregorab7897a2008-11-19 22:57:39 +00006224 // Overload resolution succeeded; we'll build the appropriate call
6225 // below.
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006226 break;
6227
6228 case OR_No_Viable_Function:
John McCall02374852010-01-07 02:04:15 +00006229 if (CandidateSet.empty())
6230 Diag(Object->getSourceRange().getBegin(), diag::err_ovl_no_oper)
6231 << Object->getType() << /*call*/ 1
6232 << Object->getSourceRange();
6233 else
6234 Diag(Object->getSourceRange().getBegin(),
6235 diag::err_ovl_no_viable_object_call)
6236 << Object->getType() << Object->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00006237 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006238 break;
6239
6240 case OR_Ambiguous:
6241 Diag(Object->getSourceRange().getBegin(),
6242 diag::err_ovl_ambiguous_object_call)
Chris Lattner1e5665e2008-11-24 06:25:27 +00006243 << Object->getType() << Object->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00006244 PrintOverloadCandidates(CandidateSet, OCD_ViableCandidates, Args, NumArgs);
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006245 break;
Douglas Gregor171c45a2009-02-18 21:56:37 +00006246
6247 case OR_Deleted:
6248 Diag(Object->getSourceRange().getBegin(),
6249 diag::err_ovl_deleted_object_call)
6250 << Best->Function->isDeleted()
6251 << Object->getType() << Object->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00006252 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor171c45a2009-02-18 21:56:37 +00006253 break;
Mike Stump11289f42009-09-09 15:08:12 +00006254 }
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006255
Douglas Gregorab7897a2008-11-19 22:57:39 +00006256 if (Best == CandidateSet.end()) {
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006257 // We had an error; delete all of the subexpressions and return
6258 // the error.
Ted Kremenek5a201952009-02-07 01:47:29 +00006259 Object->Destroy(Context);
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006260 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx)
Ted Kremenek5a201952009-02-07 01:47:29 +00006261 Args[ArgIdx]->Destroy(Context);
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006262 return true;
6263 }
6264
Douglas Gregorab7897a2008-11-19 22:57:39 +00006265 if (Best->Function == 0) {
6266 // Since there is no function declaration, this is one of the
6267 // surrogate candidates. Dig out the conversion function.
Mike Stump11289f42009-09-09 15:08:12 +00006268 CXXConversionDecl *Conv
Douglas Gregorab7897a2008-11-19 22:57:39 +00006269 = cast<CXXConversionDecl>(
6270 Best->Conversions[0].UserDefined.ConversionFunction);
6271
John McCall2cb94162010-01-28 07:38:46 +00006272 CheckMemberOperatorAccess(LParenLoc, Object, Conv, Best->getAccess());
John McCall49ec2e62010-01-28 01:54:34 +00006273
Douglas Gregorab7897a2008-11-19 22:57:39 +00006274 // We selected one of the surrogate functions that converts the
6275 // object parameter to a function pointer. Perform the conversion
6276 // on the object argument, then let ActOnCallExpr finish the job.
Fariborz Jahanian774cf792009-09-28 18:35:46 +00006277
6278 // Create an implicit member expr to refer to the conversion operator.
Fariborz Jahanian78cfcb52009-09-28 23:23:40 +00006279 // and then call it.
Eli Friedmana958a012009-12-09 04:52:43 +00006280 CXXMemberCallExpr *CE = BuildCXXMemberCallExpr(Object, Conv);
Fariborz Jahanian78cfcb52009-09-28 23:23:40 +00006281
Fariborz Jahanian774cf792009-09-28 18:35:46 +00006282 return ActOnCallExpr(S, ExprArg(*this, CE), LParenLoc,
Sebastian Redlc215cfc2009-01-19 00:08:26 +00006283 MultiExprArg(*this, (ExprTy**)Args, NumArgs),
6284 CommaLocs, RParenLoc).release();
Douglas Gregorab7897a2008-11-19 22:57:39 +00006285 }
6286
John McCall2cb94162010-01-28 07:38:46 +00006287 CheckMemberOperatorAccess(LParenLoc, Object,
6288 Best->Function, Best->getAccess());
John McCall49ec2e62010-01-28 01:54:34 +00006289
Douglas Gregorab7897a2008-11-19 22:57:39 +00006290 // We found an overloaded operator(). Build a CXXOperatorCallExpr
6291 // that calls this method, using Object for the implicit object
6292 // parameter and passing along the remaining arguments.
6293 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
John McCall9dd450b2009-09-21 23:43:11 +00006294 const FunctionProtoType *Proto = Method->getType()->getAs<FunctionProtoType>();
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006295
6296 unsigned NumArgsInProto = Proto->getNumArgs();
6297 unsigned NumArgsToCheck = NumArgs;
6298
6299 // Build the full argument list for the method call (the
6300 // implicit object parameter is placed at the beginning of the
6301 // list).
6302 Expr **MethodArgs;
6303 if (NumArgs < NumArgsInProto) {
6304 NumArgsToCheck = NumArgsInProto;
6305 MethodArgs = new Expr*[NumArgsInProto + 1];
6306 } else {
6307 MethodArgs = new Expr*[NumArgs + 1];
6308 }
6309 MethodArgs[0] = Object;
6310 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx)
6311 MethodArgs[ArgIdx + 1] = Args[ArgIdx];
Mike Stump11289f42009-09-09 15:08:12 +00006312
6313 Expr *NewFn = new (Context) DeclRefExpr(Method, Method->getType(),
Ted Kremenek5a201952009-02-07 01:47:29 +00006314 SourceLocation());
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006315 UsualUnaryConversions(NewFn);
6316
6317 // Once we've built TheCall, all of the expressions are properly
6318 // owned.
6319 QualType ResultTy = Method->getResultType().getNonReferenceType();
Mike Stump11289f42009-09-09 15:08:12 +00006320 ExprOwningPtr<CXXOperatorCallExpr>
6321 TheCall(this, new (Context) CXXOperatorCallExpr(Context, OO_Call, NewFn,
Douglas Gregor1baf54e2009-03-13 18:40:31 +00006322 MethodArgs, NumArgs + 1,
Ted Kremenek5a201952009-02-07 01:47:29 +00006323 ResultTy, RParenLoc));
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006324 delete [] MethodArgs;
6325
Anders Carlsson3d5829c2009-10-13 21:49:31 +00006326 if (CheckCallReturnType(Method->getResultType(), LParenLoc, TheCall.get(),
6327 Method))
6328 return true;
6329
Douglas Gregor02a0acd2009-01-13 05:10:00 +00006330 // We may have default arguments. If so, we need to allocate more
6331 // slots in the call for them.
6332 if (NumArgs < NumArgsInProto)
Ted Kremenek5a201952009-02-07 01:47:29 +00006333 TheCall->setNumArgs(Context, NumArgsInProto + 1);
Douglas Gregor02a0acd2009-01-13 05:10:00 +00006334 else if (NumArgs > NumArgsInProto)
6335 NumArgsToCheck = NumArgsInProto;
6336
Chris Lattnera8a7d0f2009-04-12 08:11:20 +00006337 bool IsError = false;
6338
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006339 // Initialize the implicit object parameter.
Douglas Gregorcc3f3252010-03-03 23:55:11 +00006340 IsError |= PerformObjectArgumentInitialization(Object, /*Qualifier=*/0,
6341 Method);
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006342 TheCall->setArg(0, Object);
6343
Chris Lattnera8a7d0f2009-04-12 08:11:20 +00006344
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006345 // Check the argument types.
6346 for (unsigned i = 0; i != NumArgsToCheck; i++) {
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006347 Expr *Arg;
Douglas Gregor02a0acd2009-01-13 05:10:00 +00006348 if (i < NumArgs) {
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006349 Arg = Args[i];
Mike Stump11289f42009-09-09 15:08:12 +00006350
Douglas Gregor02a0acd2009-01-13 05:10:00 +00006351 // Pass the argument.
Anders Carlsson7c5fe482010-01-29 18:43:53 +00006352
6353 OwningExprResult InputInit
6354 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
6355 Method->getParamDecl(i)),
6356 SourceLocation(), Owned(Arg));
6357
6358 IsError |= InputInit.isInvalid();
6359 Arg = InputInit.takeAs<Expr>();
Douglas Gregor02a0acd2009-01-13 05:10:00 +00006360 } else {
Douglas Gregor1bc688d2009-11-09 19:27:57 +00006361 OwningExprResult DefArg
6362 = BuildCXXDefaultArgExpr(LParenLoc, Method, Method->getParamDecl(i));
6363 if (DefArg.isInvalid()) {
6364 IsError = true;
6365 break;
6366 }
6367
6368 Arg = DefArg.takeAs<Expr>();
Douglas Gregor02a0acd2009-01-13 05:10:00 +00006369 }
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006370
6371 TheCall->setArg(i + 1, Arg);
6372 }
6373
6374 // If this is a variadic call, handle args passed through "...".
6375 if (Proto->isVariadic()) {
6376 // Promote the arguments (C99 6.5.2.2p7).
6377 for (unsigned i = NumArgsInProto; i != NumArgs; i++) {
6378 Expr *Arg = Args[i];
Chris Lattnera8a7d0f2009-04-12 08:11:20 +00006379 IsError |= DefaultVariadicArgumentPromotion(Arg, VariadicMethod);
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006380 TheCall->setArg(i + 1, Arg);
6381 }
6382 }
6383
Chris Lattnera8a7d0f2009-04-12 08:11:20 +00006384 if (IsError) return true;
6385
Anders Carlssonbc4c1072009-08-16 01:56:34 +00006386 if (CheckFunctionCall(Method, TheCall.get()))
6387 return true;
6388
Anders Carlsson1c83deb2009-08-16 03:53:54 +00006389 return MaybeBindToTemporary(TheCall.release()).release();
Douglas Gregor91cea0a2008-11-19 21:05:33 +00006390}
6391
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006392/// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
Mike Stump11289f42009-09-09 15:08:12 +00006393/// (if one exists), where @c Base is an expression of class type and
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006394/// @c Member is the name of the member we're trying to find.
Douglas Gregord8061562009-08-06 03:17:00 +00006395Sema::OwningExprResult
6396Sema::BuildOverloadedArrowExpr(Scope *S, ExprArg BaseIn, SourceLocation OpLoc) {
6397 Expr *Base = static_cast<Expr *>(BaseIn.get());
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006398 assert(Base->getType()->isRecordType() && "left-hand side must have class type");
Mike Stump11289f42009-09-09 15:08:12 +00006399
John McCallbc077cf2010-02-08 23:07:23 +00006400 SourceLocation Loc = Base->getExprLoc();
6401
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006402 // C++ [over.ref]p1:
6403 //
6404 // [...] An expression x->m is interpreted as (x.operator->())->m
6405 // for a class object x of type T if T::operator->() exists and if
6406 // the operator is selected as the best match function by the
6407 // overload resolution mechanism (13.3).
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006408 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Arrow);
John McCallbc077cf2010-02-08 23:07:23 +00006409 OverloadCandidateSet CandidateSet(Loc);
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006410 const RecordType *BaseRecord = Base->getType()->getAs<RecordType>();
Douglas Gregord8061562009-08-06 03:17:00 +00006411
John McCallbc077cf2010-02-08 23:07:23 +00006412 if (RequireCompleteType(Loc, Base->getType(),
Eli Friedman132e70b2009-11-18 01:28:03 +00006413 PDiag(diag::err_typecheck_incomplete_tag)
6414 << Base->getSourceRange()))
6415 return ExprError();
6416
John McCall27b18f82009-11-17 02:14:36 +00006417 LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName);
6418 LookupQualifiedName(R, BaseRecord->getDecl());
6419 R.suppressDiagnostics();
Anders Carlsson78b54932009-09-10 23:18:36 +00006420
6421 for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
John McCall6e9f8f62009-12-03 04:06:58 +00006422 Oper != OperEnd; ++Oper) {
6423 NamedDecl *D = *Oper;
6424 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
6425 if (isa<UsingShadowDecl>(D))
6426 D = cast<UsingShadowDecl>(D)->getTargetDecl();
6427
John McCallb89836b2010-01-26 01:37:31 +00006428 AddMethodCandidate(cast<CXXMethodDecl>(D), Oper.getAccess(), ActingContext,
John McCall6e9f8f62009-12-03 04:06:58 +00006429 Base->getType(), 0, 0, CandidateSet,
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006430 /*SuppressUserConversions=*/false);
John McCall6e9f8f62009-12-03 04:06:58 +00006431 }
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006432
6433 // Perform overload resolution.
6434 OverloadCandidateSet::iterator Best;
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00006435 switch (BestViableFunction(CandidateSet, OpLoc, Best)) {
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006436 case OR_Success:
6437 // Overload resolution succeeded; we'll build the call below.
6438 break;
6439
6440 case OR_No_Viable_Function:
6441 if (CandidateSet.empty())
6442 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
Douglas Gregord8061562009-08-06 03:17:00 +00006443 << Base->getType() << Base->getSourceRange();
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006444 else
6445 Diag(OpLoc, diag::err_ovl_no_viable_oper)
Douglas Gregord8061562009-08-06 03:17:00 +00006446 << "operator->" << Base->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00006447 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, &Base, 1);
Douglas Gregord8061562009-08-06 03:17:00 +00006448 return ExprError();
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006449
6450 case OR_Ambiguous:
6451 Diag(OpLoc, diag::err_ovl_ambiguous_oper)
Anders Carlsson78b54932009-09-10 23:18:36 +00006452 << "->" << Base->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00006453 PrintOverloadCandidates(CandidateSet, OCD_ViableCandidates, &Base, 1);
Douglas Gregord8061562009-08-06 03:17:00 +00006454 return ExprError();
Douglas Gregor171c45a2009-02-18 21:56:37 +00006455
6456 case OR_Deleted:
6457 Diag(OpLoc, diag::err_ovl_deleted_oper)
6458 << Best->Function->isDeleted()
Anders Carlsson78b54932009-09-10 23:18:36 +00006459 << "->" << Base->getSourceRange();
John McCallad907772010-01-12 07:18:19 +00006460 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, &Base, 1);
Douglas Gregord8061562009-08-06 03:17:00 +00006461 return ExprError();
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006462 }
6463
6464 // Convert the object parameter.
6465 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
Douglas Gregorcc3f3252010-03-03 23:55:11 +00006466 if (PerformObjectArgumentInitialization(Base, /*Qualifier=*/0, Method))
Douglas Gregord8061562009-08-06 03:17:00 +00006467 return ExprError();
Douglas Gregor9ecea262008-11-21 03:04:22 +00006468
6469 // No concerns about early exits now.
Douglas Gregord8061562009-08-06 03:17:00 +00006470 BaseIn.release();
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006471
6472 // Build the operator call.
Ted Kremenek5a201952009-02-07 01:47:29 +00006473 Expr *FnExpr = new (Context) DeclRefExpr(Method, Method->getType(),
6474 SourceLocation());
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006475 UsualUnaryConversions(FnExpr);
Anders Carlssone4f4b5e2009-10-13 22:43:21 +00006476
6477 QualType ResultTy = Method->getResultType().getNonReferenceType();
6478 ExprOwningPtr<CXXOperatorCallExpr>
6479 TheCall(this, new (Context) CXXOperatorCallExpr(Context, OO_Arrow, FnExpr,
6480 &Base, 1, ResultTy, OpLoc));
6481
6482 if (CheckCallReturnType(Method->getResultType(), OpLoc, TheCall.get(),
6483 Method))
6484 return ExprError();
6485 return move(TheCall);
Douglas Gregore0e79bd2008-11-20 16:27:02 +00006486}
6487
Douglas Gregorcd695e52008-11-10 20:40:00 +00006488/// FixOverloadedFunctionReference - E is an expression that refers to
6489/// a C++ overloaded function (possibly with some parentheses and
6490/// perhaps a '&' around it). We have resolved the overloaded function
6491/// to the function declaration Fn, so patch up the expression E to
Anders Carlssonfcb4ab42009-10-21 17:16:23 +00006492/// refer (possibly indirectly) to Fn. Returns the new expr.
6493Expr *Sema::FixOverloadedFunctionReference(Expr *E, FunctionDecl *Fn) {
Douglas Gregorcd695e52008-11-10 20:40:00 +00006494 if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
Douglas Gregor51c538b2009-11-20 19:42:02 +00006495 Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(), Fn);
6496 if (SubExpr == PE->getSubExpr())
6497 return PE->Retain();
6498
6499 return new (Context) ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr);
6500 }
6501
6502 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
6503 Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(), Fn);
Douglas Gregor091f0422009-10-23 22:18:25 +00006504 assert(Context.hasSameType(ICE->getSubExpr()->getType(),
Douglas Gregor51c538b2009-11-20 19:42:02 +00006505 SubExpr->getType()) &&
Douglas Gregor091f0422009-10-23 22:18:25 +00006506 "Implicit cast type cannot be determined from overload");
Douglas Gregor51c538b2009-11-20 19:42:02 +00006507 if (SubExpr == ICE->getSubExpr())
6508 return ICE->Retain();
6509
6510 return new (Context) ImplicitCastExpr(ICE->getType(),
6511 ICE->getCastKind(),
6512 SubExpr,
6513 ICE->isLvalueCast());
6514 }
6515
6516 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E)) {
Mike Stump11289f42009-09-09 15:08:12 +00006517 assert(UnOp->getOpcode() == UnaryOperator::AddrOf &&
Douglas Gregorcd695e52008-11-10 20:40:00 +00006518 "Can only take the address of an overloaded function");
Douglas Gregor6f233ef2009-02-11 01:18:59 +00006519 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
6520 if (Method->isStatic()) {
6521 // Do nothing: static member functions aren't any different
6522 // from non-member functions.
John McCalld14a8642009-11-21 08:51:07 +00006523 } else {
John McCalle66edc12009-11-24 19:00:30 +00006524 // Fix the sub expression, which really has to be an
6525 // UnresolvedLookupExpr holding an overloaded member function
6526 // or template.
John McCalld14a8642009-11-21 08:51:07 +00006527 Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(), Fn);
6528 if (SubExpr == UnOp->getSubExpr())
6529 return UnOp->Retain();
Douglas Gregor51c538b2009-11-20 19:42:02 +00006530
John McCalld14a8642009-11-21 08:51:07 +00006531 assert(isa<DeclRefExpr>(SubExpr)
6532 && "fixed to something other than a decl ref");
6533 assert(cast<DeclRefExpr>(SubExpr)->getQualifier()
6534 && "fixed to a member ref with no nested name qualifier");
6535
6536 // We have taken the address of a pointer to member
6537 // function. Perform the computation here so that we get the
6538 // appropriate pointer to member type.
6539 QualType ClassType
6540 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
6541 QualType MemPtrType
6542 = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
6543
6544 return new (Context) UnaryOperator(SubExpr, UnaryOperator::AddrOf,
6545 MemPtrType, UnOp->getOperatorLoc());
Douglas Gregor6f233ef2009-02-11 01:18:59 +00006546 }
6547 }
Douglas Gregor51c538b2009-11-20 19:42:02 +00006548 Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(), Fn);
6549 if (SubExpr == UnOp->getSubExpr())
6550 return UnOp->Retain();
Anders Carlssonfcb4ab42009-10-21 17:16:23 +00006551
Douglas Gregor51c538b2009-11-20 19:42:02 +00006552 return new (Context) UnaryOperator(SubExpr, UnaryOperator::AddrOf,
6553 Context.getPointerType(SubExpr->getType()),
6554 UnOp->getOperatorLoc());
Douglas Gregor51c538b2009-11-20 19:42:02 +00006555 }
John McCalld14a8642009-11-21 08:51:07 +00006556
6557 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
John McCall2d74de92009-12-01 22:10:20 +00006558 // FIXME: avoid copy.
6559 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0;
John McCalle66edc12009-11-24 19:00:30 +00006560 if (ULE->hasExplicitTemplateArgs()) {
John McCall2d74de92009-12-01 22:10:20 +00006561 ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
6562 TemplateArgs = &TemplateArgsBuffer;
John McCalle66edc12009-11-24 19:00:30 +00006563 }
6564
John McCalld14a8642009-11-21 08:51:07 +00006565 return DeclRefExpr::Create(Context,
6566 ULE->getQualifier(),
6567 ULE->getQualifierRange(),
6568 Fn,
6569 ULE->getNameLoc(),
John McCall2d74de92009-12-01 22:10:20 +00006570 Fn->getType(),
6571 TemplateArgs);
John McCalld14a8642009-11-21 08:51:07 +00006572 }
6573
John McCall10eae182009-11-30 22:42:35 +00006574 if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) {
John McCall6b51f282009-11-23 01:53:49 +00006575 // FIXME: avoid copy.
John McCall2d74de92009-12-01 22:10:20 +00006576 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0;
6577 if (MemExpr->hasExplicitTemplateArgs()) {
6578 MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
6579 TemplateArgs = &TemplateArgsBuffer;
6580 }
John McCall6b51f282009-11-23 01:53:49 +00006581
John McCall2d74de92009-12-01 22:10:20 +00006582 Expr *Base;
6583
6584 // If we're filling in
6585 if (MemExpr->isImplicitAccess()) {
6586 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
6587 return DeclRefExpr::Create(Context,
6588 MemExpr->getQualifier(),
6589 MemExpr->getQualifierRange(),
6590 Fn,
6591 MemExpr->getMemberLoc(),
6592 Fn->getType(),
6593 TemplateArgs);
Douglas Gregorb15af892010-01-07 23:12:05 +00006594 } else {
6595 SourceLocation Loc = MemExpr->getMemberLoc();
6596 if (MemExpr->getQualifier())
6597 Loc = MemExpr->getQualifierRange().getBegin();
6598 Base = new (Context) CXXThisExpr(Loc,
6599 MemExpr->getBaseType(),
6600 /*isImplicit=*/true);
6601 }
John McCall2d74de92009-12-01 22:10:20 +00006602 } else
6603 Base = MemExpr->getBase()->Retain();
6604
6605 return MemberExpr::Create(Context, Base,
Douglas Gregor51c538b2009-11-20 19:42:02 +00006606 MemExpr->isArrow(),
6607 MemExpr->getQualifier(),
6608 MemExpr->getQualifierRange(),
6609 Fn,
John McCall6b51f282009-11-23 01:53:49 +00006610 MemExpr->getMemberLoc(),
John McCall2d74de92009-12-01 22:10:20 +00006611 TemplateArgs,
Douglas Gregor51c538b2009-11-20 19:42:02 +00006612 Fn->getType());
6613 }
6614
Douglas Gregor51c538b2009-11-20 19:42:02 +00006615 assert(false && "Invalid reference to overloaded function");
6616 return E->Retain();
Douglas Gregorcd695e52008-11-10 20:40:00 +00006617}
6618
Douglas Gregor3e1e5272009-12-09 23:02:17 +00006619Sema::OwningExprResult Sema::FixOverloadedFunctionReference(OwningExprResult E,
6620 FunctionDecl *Fn) {
6621 return Owned(FixOverloadedFunctionReference((Expr *)E.get(), Fn));
6622}
6623
Douglas Gregor5251f1b2008-10-21 16:13:35 +00006624} // end namespace clang